'../src/core/ARGB32_Clamp_Bilinear_BitmapShader.h',
'../src/core/Sk64.cpp',
'../src/core/SkAAClip.cpp',
+ '../src/core/SkAnnotation.cpp',
'../src/core/SkAdvancedTypefaceMetrics.cpp',
'../src/core/SkAlphaRuns.cpp',
'../src/core/SkAntiRun.h',
],
'sources': [
'../tests/AAClipTest.cpp',
+ '../tests/AnnotationTest.cpp',
'../tests/BitmapCopyTest.cpp',
'../tests/BitmapGetColorTest.cpp',
'../tests/BitSetTest.cpp',
--- /dev/null
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkAnnotation_DEFINED
+#define SkAnnotation_DEFINED
+
+#include "SkFlattenable.h"
+
+class SkData;
+class SkDataSet;
+
+/**
+ * Experimental class for annotating draws. Do not use directly yet.
+ * Use helper functions at the bottom of this file for now.
+ */
+class SkAnnotation : public SkFlattenable {
+public:
+ enum Flags {
+ // If set, the associated drawing primitive should not be drawn
+ kNoDraw_Flag = 1 << 0,
+ };
+
+ SkAnnotation(SkDataSet*, uint32_t flags);
+ virtual ~SkAnnotation();
+
+ uint32_t getFlags() const { return fFlags; }
+ SkDataSet* getDataSet() const { return fDataSet; }
+
+ bool isNoDraw() const { return SkToBool(fFlags & kNoDraw_Flag); }
+
+ /**
+ * Helper for search the annotation's dataset.
+ */
+ SkData* find(const char name[]) const;
+
+ SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkAnnotation)
+
+protected:
+ SkAnnotation(SkFlattenableReadBuffer&);
+ virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+
+private:
+ SkDataSet* fDataSet;
+ uint32_t fFlags;
+
+ void writeToStream(SkWStream*) const;
+ void readFromStream(SkStream*);
+
+ typedef SkFlattenable INHERITED;
+};
+
+/**
+ * Experimental collection of predefined Keys into the Annotation dictionary
+ */
+class SkAnnotationKeys {
+public:
+ /**
+ * Returns the canonical key whose payload is a URL
+ */
+ static const char* URL_Key();
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Experimental helper functions to use Annotations
+//
+
+struct SkRect;
+class SkCanvas;
+
+/**
+ * Experimental!
+ *
+ * Annotate the canvas by associating the specified URL with the
+ * specified rectangle (in local coordinates, just like drawRect). If the
+ * backend of this canvas does not support annotations, this call is
+ * safely ignored.
+ *
+ * The caller is responsible for managing its ownership of the SkData.
+ */
+SK_API void SkAnnotateRectWithURL(SkCanvas*, const SkRect&, SkData*);
+
+#endif
#include "SkDrawLooper.h"
#include "SkXfermode.h"
+class SkAnnotation;
class SkAutoGlyphCache;
class SkColorFilter;
class SkDescriptor;
SkImageFilter* getImageFilter() const { return fImageFilter; }
SkImageFilter* setImageFilter(SkImageFilter*);
+
+ SkAnnotation* getAnnotation() const { return fAnnotation; }
+ SkAnnotation* setAnnotation(SkAnnotation*);
+
+ /**
+ * Returns true if there is an annotation installed on this paint, and
+ * the annotation specifics no-drawing.
+ */
+ bool isNoDrawAnnotation() const {
+ return SkToBool(fPrivFlags & kNoDrawAnnotation_PrivFlag);
+ }
/**
* Return the paint's SkDrawLooper (if any). Does not affect the looper's
SkRasterizer* fRasterizer;
SkDrawLooper* fLooper;
SkImageFilter* fImageFilter;
+ SkAnnotation* fAnnotation;
SkColor fColor;
SkScalar fWidth;
SkScalar fMiterLimit;
- unsigned fFlags : 15;
+ // all of these bitfields should add up to 32
+ unsigned fFlags : 16;
unsigned fTextAlign : 2;
unsigned fCapType : 2;
unsigned fJoinType : 2;
unsigned fStyle : 2;
unsigned fTextEncoding : 2; // 3 values
unsigned fHinting : 2;
+ unsigned fPrivFlags : 4; // these are not flattened/unflattened
+
+ enum PrivFlags {
+ kNoDrawAnnotation_PrivFlag = 1 << 0,
+ };
SkDrawCacheProc getDrawCacheProc() const;
SkMeasureCacheProc getMeasureCacheProc(TextBufferDirection dir,
--- /dev/null
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkAnnotation.h"
+#include "SkDataSet.h"
+#include "SkStream.h"
+
+SkAnnotation::SkAnnotation(SkDataSet* data, uint32_t flags) {
+ if (NULL == data) {
+ data = SkDataSet::NewEmpty();
+ } else {
+ data->ref();
+ }
+ fDataSet = data;
+ fFlags = flags;
+}
+
+SkAnnotation::~SkAnnotation() {
+ fDataSet->unref();
+}
+
+SkAnnotation::SkAnnotation(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
+ fFlags = buffer.readU32();
+ fDataSet = SkNEW_ARGS(SkDataSet, (buffer));
+}
+
+void SkAnnotation::flatten(SkFlattenableWriteBuffer& buffer) const {
+ buffer.write32(fFlags);
+ fDataSet->flatten(buffer);
+}
+
+SK_DEFINE_FLATTENABLE_REGISTRAR(SkAnnotation)
+
+const char* SkAnnotationKeys::URL_Key() {
+ return "SkAnnotationKey_URL";
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+#include "SkCanvas.h"
+
+void SkAnnotateRectWithURL(SkCanvas* canvas, const SkRect& rect, SkData* value) {
+ if (NULL == value) {
+ return;
+ }
+
+ const char* key = SkAnnotationKeys::URL_Key();
+ SkAutoTUnref<SkDataSet> dataset(SkNEW_ARGS(SkDataSet, (key, value)));
+ SkAnnotation* ann = SkNEW_ARGS(SkAnnotation, (dataset,
+ SkAnnotation::kNoDraw_Flag));
+
+ SkPaint paint;
+ paint.setAnnotation(ann)->unref();
+ SkASSERT(paint.isNoDrawAnnotation());
+
+ canvas->drawRect(rect, paint);
+}
+
///////////////////////////////////////////////////////////////////////////////
+#define CHECK_FOR_NODRAW_ANNOTATION(paint) \
+ do { if (paint.isNoDrawAnnotation()) { return; } } while (0)
+
+///////////////////////////////////////////////////////////////////////////////
+
SkDevice::SkDevice(const SkBitmap& bitmap) : fBitmap(bitmap) {
fOrigin.setZero();
fMetaData = NULL;
void SkDevice::drawRect(const SkDraw& draw, const SkRect& r,
const SkPaint& paint) {
+ CHECK_FOR_NODRAW_ANNOTATION(paint);
draw.drawRect(r, paint);
}
void SkDevice::drawPath(const SkDraw& draw, const SkPath& path,
const SkPaint& paint, const SkMatrix* prePathMatrix,
bool pathIsMutable) {
+ CHECK_FOR_NODRAW_ANNOTATION(paint);
draw.drawPath(path, paint, prePathMatrix, pathIsMutable);
}
* found in the LICENSE file.
*/
-
#include "SkPaint.h"
+#include "SkAnnotation.h"
#include "SkColorFilter.h"
#include "SkFontHost.h"
#include "SkImageFilter.h"
fRasterizer = NULL;
fLooper = NULL;
fImageFilter = NULL;
+ fAnnotation = NULL;
fWidth = 0;
#endif
fStyle = kFill_Style;
fTextEncoding = kUTF8_TextEncoding;
fHinting = SkPaintDefaults_Hinting;
+ fPrivFlags = 0;
#ifdef SK_BUILD_FOR_ANDROID
fGenerationID = 0;
#endif
SkSafeRef(fRasterizer);
SkSafeRef(fLooper);
SkSafeRef(fImageFilter);
+ SkSafeRef(fAnnotation);
}
SkPaint::~SkPaint() {
SkSafeUnref(fRasterizer);
SkSafeUnref(fLooper);
SkSafeUnref(fImageFilter);
+ SkSafeUnref(fAnnotation);
}
SkPaint& SkPaint::operator=(const SkPaint& src) {
SkSafeRef(src.fRasterizer);
SkSafeRef(src.fLooper);
SkSafeRef(src.fImageFilter);
+ SkSafeRef(src.fAnnotation);
SkSafeUnref(fTypeface);
SkSafeUnref(fPathEffect);
SkSafeUnref(fRasterizer);
SkSafeUnref(fLooper);
SkSafeUnref(fImageFilter);
+ SkSafeUnref(fAnnotation);
#ifdef SK_BUILD_FOR_ANDROID
uint32_t oldGenerationID = fGenerationID;
return imageFilter;
}
+SkAnnotation* SkPaint::setAnnotation(SkAnnotation* annotation) {
+ SkRefCnt_SafeAssign(fAnnotation, annotation);
+ GEN_ID_INC;
+
+ bool isNoDraw = annotation && annotation->isNoDraw();
+ fPrivFlags = SkSetClearMask(fPrivFlags, isNoDraw, kNoDrawAnnotation_PrivFlag);
+
+ return annotation;
+}
+
///////////////////////////////////////////////////////////////////////////////
#include "SkGlyphCache.h"
enum FlatFlags {
kHasTypeface_FlatFlag = 0x01,
- kHasEffects_FlatFlag = 0x02
+ kHasEffects_FlatFlag = 0x02,
};
// The size of a flat paint's POD fields
asint(this->getColorFilter()) |
asint(this->getRasterizer()) |
asint(this->getLooper()) |
+ asint(this->getAnnotation()) |
asint(this->getImageFilter())) {
flatFlags |= kHasEffects_FlatFlag;
}
buffer.writeFlattenable(this->getRasterizer());
buffer.writeFlattenable(this->getLooper());
buffer.writeFlattenable(this->getImageFilter());
+ buffer.writeFlattenable(this->getAnnotation());
}
}
const void* podData = buffer.skip(kPODPaintSize);
const uint32_t* pod = reinterpret_cast<const uint32_t*>(podData);
+ fPrivFlags = 0;
+
// the order we read must match the order we wrote in flatten()
this->setTextSize(read_scalar(pod));
this->setTextScaleX(read_scalar(pod));
SkSafeUnref(this->setRasterizer((SkRasterizer*) buffer.readFlattenable()));
SkSafeUnref(this->setLooper((SkDrawLooper*) buffer.readFlattenable()));
SkSafeUnref(this->setImageFilter((SkImageFilter*) buffer.readFlattenable()));
+ SkSafeUnref(this->setAnnotation((SkAnnotation*) buffer.readFlattenable()));
} else {
this->setPathEffect(NULL);
this->setShader(NULL);
return false;
}
-//////
+////////////////////
SK_DEFINE_INST_COUNT(SkDrawLooper)
///////////////////////////////////////////////////////////////////////////////
+#define CHECK_FOR_NODRAW_ANNOTATION(paint) \
+ do { if (paint.isNoDrawAnnotation()) { return; } } while (0)
+
+///////////////////////////////////////////////////////////////////////////////
+
+
class SkGpuDevice::SkAutoCachedTexture : public ::SkNoncopyable {
public:
SkAutoCachedTexture() { }
void SkGpuDevice::drawRect(const SkDraw& draw, const SkRect& rect,
const SkPaint& paint) {
+ CHECK_FOR_NODRAW_ANNOTATION(paint);
CHECK_SHOULD_DRAW(draw);
bool doStroke = paint.getStyle() != SkPaint::kFill_Style;
void SkGpuDevice::drawPath(const SkDraw& draw, const SkPath& origSrcPath,
const SkPaint& paint, const SkMatrix* prePathMatrix,
bool pathIsMutable) {
+ CHECK_FOR_NODRAW_ANNOTATION(paint);
CHECK_SHOULD_DRAW(draw);
bool doFill = true;
--- /dev/null
+
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#include "Test.h"
+#include "SkAnnotation.h"
+#include "SkData.h"
+#include "SkCanvas.h"
+
+static void test_nodraw(skiatest::Reporter* reporter) {
+ SkBitmap bm;
+ bm.setConfig(SkBitmap::kARGB_8888_Config, 10, 10);
+ bm.allocPixels();
+ bm.eraseColor(0);
+
+ SkCanvas canvas(bm);
+ SkRect r = SkRect::MakeWH(SkIntToScalar(10), SkIntToScalar(10));
+
+ SkAutoDataUnref data(SkData::NewWithCString("http://www.gooogle.com"));
+
+ REPORTER_ASSERT(reporter, 0 == *bm.getAddr32(0, 0));
+ SkAnnotateRectWithURL(&canvas, r, data.get());
+ REPORTER_ASSERT(reporter, 0 == *bm.getAddr32(0, 0));
+}
+
+static void TestAnnotation(skiatest::Reporter* reporter) {
+ test_nodraw(reporter);
+}
+
+#include "TestClassDef.h"
+DEFINE_TESTCLASS("Annotation", AnnotationClass, TestAnnotation)
projects / platform / upstream / libSkiaSharp.git / commitdiff