michael@0: /*
michael@0:  * Copyright 2014 Google Inc.
michael@0:  *
michael@0:  * Use of this source code is governed by a BSD-style license that can be
michael@0:  * found in the LICENSE file.
michael@0:  */
michael@0: 
michael@0: #ifndef SkGatherPixelRefsAndRects_DEFINED
michael@0: #define SkGatherPixelRefsAndRects_DEFINED
michael@0: 
michael@0: #include "SkBitmap.h"
michael@0: #include "SkDevice.h"
michael@0: #include "SkDraw.h"
michael@0: #include "SkPictureUtils.h"
michael@0: #include "SkRasterClip.h"
michael@0: #include "SkRefCnt.h"
michael@0: #include "SkRRect.h"
michael@0: #include "SkTypes.h"
michael@0: 
michael@0: // This GatherPixelRefs device passes all discovered pixel refs and their
michael@0: // device bounds to the user provided SkPixelRefContainer-derived object
michael@0: class SkGatherPixelRefsAndRectsDevice : public SkBaseDevice {
michael@0: public:
michael@0:     SK_DECLARE_INST_COUNT(SkGatherPixelRefsAndRectsDevice)
michael@0: 
michael@0:     SkGatherPixelRefsAndRectsDevice(int width, int height,
michael@0:                                     SkPictureUtils::SkPixelRefContainer* prCont) {
michael@0:         fSize.set(width, height);
michael@0:         fPRCont = prCont;
michael@0:         SkSafeRef(fPRCont);
michael@0:         fEmptyBitmap.setConfig(SkImageInfo::Make(width, height,
michael@0:                                                  kUnknown_SkColorType,
michael@0:                                                  kIgnore_SkAlphaType));
michael@0:     }
michael@0: 
michael@0:     virtual ~SkGatherPixelRefsAndRectsDevice() {
michael@0:         SkSafeUnref(fPRCont);
michael@0:     }
michael@0: 
michael@0:     virtual int width() const SK_OVERRIDE { return fSize.width(); }
michael@0:     virtual int height() const SK_OVERRIDE { return fSize.height(); }
michael@0:     virtual bool isOpaque() const SK_OVERRIDE { return false; }
michael@0:     virtual SkBitmap::Config config() const SK_OVERRIDE {
michael@0:         return SkBitmap::kNo_Config;
michael@0:     }
michael@0:     virtual SkImageInfo imageInfo() const SK_OVERRIDE {
michael@0:         return fEmptyBitmap.info();
michael@0:     }
michael@0: 
michael@0: #ifdef SK_SUPPORT_LEGACY_WRITEPIXELSCONFIG
michael@0:     virtual void writePixels(const SkBitmap& bitmap, int x, int y,
michael@0:                              SkCanvas::Config8888 config8888) SK_OVERRIDE {
michael@0:         NotSupported();
michael@0:     }
michael@0: #endif
michael@0:     virtual GrRenderTarget* accessRenderTarget() SK_OVERRIDE { return NULL; }
michael@0: 
michael@0: protected:
michael@0:     virtual bool filterTextFlags(const SkPaint& paint, TextFlags*) SK_OVERRIDE {
michael@0:         return false;
michael@0:     }
michael@0:     virtual void clear(SkColor color) SK_OVERRIDE {
michael@0:         NothingToDo();
michael@0:     }
michael@0:     virtual void drawPaint(const SkDraw& draw, const SkPaint& paint) SK_OVERRIDE {
michael@0:         SkBitmap bm;
michael@0: 
michael@0:         if (GetBitmapFromPaint(paint, &bm)) {
michael@0:             SkRect clipRect = SkRect::Make(draw.fRC->getBounds());
michael@0:             fPRCont->add(bm.pixelRef(), clipRect);
michael@0:         }
michael@0:     }
michael@0:     virtual void drawPoints(const SkDraw& draw, SkCanvas::PointMode mode, size_t count,
michael@0:                             const SkPoint points[], const SkPaint& paint) SK_OVERRIDE {
michael@0:         SkBitmap bm;
michael@0:         if (!GetBitmapFromPaint(paint, &bm)) {
michael@0:             return;
michael@0:         }
michael@0: 
michael@0:         if (0 == count) {
michael@0:             return;
michael@0:         }
michael@0: 
michael@0:         SkPoint min = points[0];
michael@0:         SkPoint max = points[0];
michael@0:         for (size_t i = 1; i < count; ++i) {
michael@0:             const SkPoint& point = points[i];
michael@0: 
michael@0:             min.set(SkMinScalar(min.x(), point.x()), SkMinScalar(min.y(), point.y()));
michael@0:             max.set(SkMaxScalar(max.x(), point.x()), SkMaxScalar(max.y(), point.y()));
michael@0:         }
michael@0: 
michael@0:         SkRect bounds = SkRect::MakeLTRB(min.x(), min.y(), max.x()+1, max.y()+1);
michael@0: 
michael@0:         this->drawRect(draw, bounds, paint);
michael@0:     }
michael@0:     virtual void drawRect(const SkDraw& draw, const SkRect& rect,
michael@0:                           const SkPaint& paint) SK_OVERRIDE {
michael@0:         SkBitmap bm;
michael@0:         if (GetBitmapFromPaint(paint, &bm)) {
michael@0:             SkRect mappedRect;
michael@0:             draw.fMatrix->mapRect(&mappedRect, rect);
michael@0:             SkRect clipRect = SkRect::Make(draw.fRC->getBounds());
michael@0:             mappedRect.intersect(clipRect);
michael@0:             fPRCont->add(bm.pixelRef(), mappedRect);
michael@0:         }
michael@0:     }
michael@0:     virtual void drawOval(const SkDraw& draw, const SkRect& rect,
michael@0:                           const SkPaint& paint) SK_OVERRIDE {
michael@0:         this->drawRect(draw, rect, paint);
michael@0:     }
michael@0:     virtual void drawRRect(const SkDraw& draw, const SkRRect& rrect,
michael@0:                            const SkPaint& paint) SK_OVERRIDE {
michael@0:         this->drawRect(draw, rrect.rect(), paint);
michael@0:     }
michael@0:     virtual void drawPath(const SkDraw& draw, const SkPath& path,
michael@0:                           const SkPaint& paint, const SkMatrix* prePathMatrix,
michael@0:                           bool pathIsMutable) SK_OVERRIDE {
michael@0:         SkBitmap bm;
michael@0:         if (!GetBitmapFromPaint(paint, &bm)) {
michael@0:             return;
michael@0:         }
michael@0: 
michael@0:         SkRect pathBounds = path.getBounds();
michael@0:         if (NULL != prePathMatrix) {
michael@0:             prePathMatrix->mapRect(&pathBounds);
michael@0:         }
michael@0: 
michael@0:         this->drawRect(draw, pathBounds, paint);
michael@0:     }
michael@0:     virtual void drawBitmap(const SkDraw& draw, const SkBitmap& bitmap,
michael@0:                             const SkMatrix& matrix, const SkPaint& paint) SK_OVERRIDE {
michael@0:         SkMatrix totMatrix;
michael@0:         totMatrix.setConcat(*draw.fMatrix, matrix);
michael@0: 
michael@0:         SkRect bitmapRect = SkRect::MakeWH(SkIntToScalar(bitmap.width()),
michael@0:                                            SkIntToScalar(bitmap.height()));
michael@0:         SkRect mappedRect;
michael@0:         totMatrix.mapRect(&mappedRect, bitmapRect);
michael@0:         fPRCont->add(bitmap.pixelRef(), mappedRect);
michael@0: 
michael@0:         SkBitmap paintBitmap;
michael@0:         if (GetBitmapFromPaint(paint, &paintBitmap)) {
michael@0:             fPRCont->add(paintBitmap.pixelRef(), mappedRect);
michael@0:         }
michael@0:     }
michael@0:     virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap,
michael@0:                             int x, int y, const SkPaint& paint) SK_OVERRIDE {
michael@0:         // Sprites aren't affected by current matrix, so we can't reuse drawRect.
michael@0:         SkMatrix matrix;
michael@0:         matrix.setTranslate(SkIntToScalar(x), SkIntToScalar(y));
michael@0: 
michael@0:         SkRect bitmapRect = SkRect::MakeWH(SkIntToScalar(bitmap.width()),
michael@0:                                            SkIntToScalar(bitmap.height()));
michael@0:         SkRect mappedRect;
michael@0:         matrix.mapRect(&mappedRect, bitmapRect);
michael@0:         fPRCont->add(bitmap.pixelRef(), mappedRect);
michael@0: 
michael@0:         SkBitmap paintBitmap;
michael@0:         if (GetBitmapFromPaint(paint, &paintBitmap)) {
michael@0:             fPRCont->add(paintBitmap.pixelRef(), mappedRect);
michael@0:         }
michael@0:     }
michael@0:     virtual void drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap,
michael@0:                                 const SkRect* srcOrNull, const SkRect& dst,
michael@0:                                 const SkPaint& paint,
michael@0:                                 SkCanvas::DrawBitmapRectFlags flags) SK_OVERRIDE {
michael@0:         SkRect bitmapRect = SkRect::MakeWH(SkIntToScalar(bitmap.width()),
michael@0:                                            SkIntToScalar(bitmap.height()));
michael@0:         SkMatrix matrix;
michael@0:         matrix.setRectToRect(bitmapRect, dst, SkMatrix::kFill_ScaleToFit);
michael@0:         this->drawBitmap(draw, bitmap, matrix, paint);
michael@0:     }
michael@0:     virtual void drawText(const SkDraw& draw, const void* text, size_t len,
michael@0:                           SkScalar x, SkScalar y,
michael@0:                           const SkPaint& paint) SK_OVERRIDE {
michael@0:         SkBitmap bitmap;
michael@0:         if (!GetBitmapFromPaint(paint, &bitmap)) {
michael@0:             return;
michael@0:         }
michael@0: 
michael@0:         // Math is borrowed from SkBBoxRecord
michael@0:         SkRect bounds;
michael@0:         paint.measureText(text, len, &bounds);
michael@0:         SkPaint::FontMetrics metrics;
michael@0:         paint.getFontMetrics(&metrics);
michael@0: 
michael@0:         if (paint.isVerticalText()) {
michael@0:             SkScalar h = bounds.fBottom - bounds.fTop;
michael@0:             if (paint.getTextAlign() == SkPaint::kCenter_Align) {
michael@0:                 bounds.fTop -= h / 2;
michael@0:                 bounds.fBottom -= h / 2;
michael@0:             }
michael@0:             bounds.fBottom += metrics.fBottom;
michael@0:             bounds.fTop += metrics.fTop;
michael@0:         } else {
michael@0:             SkScalar w = bounds.fRight - bounds.fLeft;
michael@0:             if (paint.getTextAlign() == SkPaint::kCenter_Align) {
michael@0:                 bounds.fLeft -= w / 2;
michael@0:                 bounds.fRight -= w / 2;
michael@0:             } else if (paint.getTextAlign() == SkPaint::kRight_Align) {
michael@0:                 bounds.fLeft -= w;
michael@0:                 bounds.fRight -= w;
michael@0:             }
michael@0:             bounds.fTop = metrics.fTop;
michael@0:             bounds.fBottom = metrics.fBottom;
michael@0:         }
michael@0: 
michael@0:         SkScalar pad = (metrics.fBottom - metrics.fTop) / 2;
michael@0:         bounds.fLeft -= pad;
michael@0:         bounds.fRight += pad;
michael@0:         bounds.offset(x, y);
michael@0: 
michael@0:         this->drawRect(draw, bounds, paint);
michael@0:     }
michael@0:     virtual void drawPosText(const SkDraw& draw, const void* text, size_t len,
michael@0:                              const SkScalar pos[], SkScalar constY,
michael@0:                              int scalarsPerPos, const SkPaint& paint) SK_OVERRIDE {
michael@0:         SkBitmap bitmap;
michael@0:         if (!GetBitmapFromPaint(paint, &bitmap)) {
michael@0:             return;
michael@0:         }
michael@0: 
michael@0:         if (0 == len) {
michael@0:             return;
michael@0:         }
michael@0: 
michael@0:         // Similar to SkDraw asserts.
michael@0:         SkASSERT(scalarsPerPos == 1 || scalarsPerPos == 2);
michael@0: 
michael@0:         SkScalar y = scalarsPerPos == 1 ? constY : constY + pos[1];
michael@0: 
michael@0:         SkPoint min, max;
michael@0:         min.set(pos[0], y);
michael@0:         max.set(pos[0], y);
michael@0: 
michael@0:         for (size_t i = 1; i < len; ++i) {
michael@0:             SkScalar x = pos[i * scalarsPerPos];
michael@0:             SkScalar y = constY;
michael@0:             if (2 == scalarsPerPos) {
michael@0:                 y += pos[i * scalarsPerPos + 1];
michael@0:             }
michael@0: 
michael@0:             min.set(SkMinScalar(x, min.x()), SkMinScalar(y, min.y()));
michael@0:             max.set(SkMaxScalar(x, max.x()), SkMaxScalar(y, max.y()));
michael@0:         }
michael@0: 
michael@0:         SkRect bounds = SkRect::MakeLTRB(min.x(), min.y(), max.x(), max.y());
michael@0: 
michael@0:         // Math is borrowed from SkBBoxRecord
michael@0:         SkPaint::FontMetrics metrics;
michael@0:         paint.getFontMetrics(&metrics);
michael@0: 
michael@0:         bounds.fTop += metrics.fTop;
michael@0:         bounds.fBottom += metrics.fBottom;
michael@0: 
michael@0:         SkScalar pad = (metrics.fTop - metrics.fBottom) / 2;
michael@0:         bounds.fLeft -= pad;
michael@0:         bounds.fRight += pad;
michael@0: 
michael@0:         this->drawRect(draw, bounds, paint);
michael@0:     }
michael@0:     virtual void drawTextOnPath(const SkDraw& draw, const void* text, size_t len,
michael@0:                                 const SkPath& path, const SkMatrix* matrix,
michael@0:                                 const SkPaint& paint) SK_OVERRIDE {
michael@0:         SkBitmap bitmap;
michael@0:         if (!GetBitmapFromPaint(paint, &bitmap)) {
michael@0:             return;
michael@0:         }
michael@0: 
michael@0:         // Math is borrowed from SkBBoxRecord
michael@0:         SkRect bounds = path.getBounds();
michael@0:         SkPaint::FontMetrics metrics;
michael@0:         paint.getFontMetrics(&metrics);
michael@0: 
michael@0:         SkScalar pad = metrics.fTop;
michael@0:         // TODO: inset?!
michael@0:         bounds.fLeft += pad;
michael@0:         bounds.fRight -= pad;
michael@0:         bounds.fTop += pad;
michael@0:         bounds.fBottom -= pad;
michael@0: 
michael@0:         this->drawRect(draw, bounds, paint);
michael@0:     }
michael@0:     virtual void drawVertices(const SkDraw& draw, SkCanvas::VertexMode, int vertexCount,
michael@0:                               const SkPoint verts[], const SkPoint texs[],
michael@0:                               const SkColor colors[], SkXfermode* xmode,
michael@0:                               const uint16_t indices[], int indexCount,
michael@0:                               const SkPaint& paint) SK_OVERRIDE {
michael@0:         this->drawPoints(draw, SkCanvas::kPolygon_PointMode, vertexCount, verts, paint);
michael@0:     }
michael@0:     virtual void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
michael@0:                             const SkPaint&) SK_OVERRIDE {
michael@0:         NothingToDo();
michael@0:     }
michael@0:     // TODO: allow this call to return failure, or move to SkBitmapDevice only.
michael@0:     virtual const SkBitmap& onAccessBitmap() SK_OVERRIDE {
michael@0:         return fEmptyBitmap;
michael@0:     }
michael@0:     virtual bool onReadPixels(const SkBitmap& bitmap,
michael@0:                               int x, int y,
michael@0:                               SkCanvas::Config8888 config8888) SK_OVERRIDE {
michael@0:         NotSupported();
michael@0:         return false;
michael@0:     }
michael@0:     virtual void lockPixels() SK_OVERRIDE { NothingToDo(); }
michael@0:     virtual void unlockPixels() SK_OVERRIDE { NothingToDo(); }
michael@0:     virtual bool allowImageFilter(const SkImageFilter*) SK_OVERRIDE { return false; }
michael@0:     virtual bool canHandleImageFilter(const SkImageFilter*) SK_OVERRIDE { return false; }
michael@0:     virtual bool filterImage(const SkImageFilter*, const SkBitmap&, const SkImageFilter::Context&,
michael@0:                              SkBitmap* result, SkIPoint* offset) SK_OVERRIDE {
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0: private:
michael@0:     SkPictureUtils::SkPixelRefContainer* fPRCont;
michael@0:     SkISize                              fSize;
michael@0: 
michael@0:     SkBitmap                             fEmptyBitmap; // legacy -- need to remove
michael@0: 
michael@0:     static bool GetBitmapFromPaint(const SkPaint &paint, SkBitmap* bitmap) {
michael@0:         SkShader* shader = paint.getShader();
michael@0:         if (NULL != shader) {
michael@0:             if (SkShader::kNone_GradientType == shader->asAGradient(NULL)) {
michael@0:                 return SkShader::kNone_BitmapType != shader->asABitmap(bitmap, NULL, NULL);
michael@0:             }
michael@0:         }
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     virtual void replaceBitmapBackendForRasterSurface(const SkBitmap&) SK_OVERRIDE {
michael@0:         NotSupported();
michael@0:     }
michael@0: 
michael@0:     virtual SkBaseDevice* onCreateDevice(const SkImageInfo& info, Usage usage) SK_OVERRIDE {
michael@0:         // we expect to only get called via savelayer, in which case it is fine.
michael@0:         SkASSERT(kSaveLayer_Usage == usage);
michael@0:         return SkNEW_ARGS(SkGatherPixelRefsAndRectsDevice,
michael@0:                           (info.width(), info.height(), fPRCont));
michael@0:     }
michael@0: 
michael@0:     virtual void flush() SK_OVERRIDE {}
michael@0: 
michael@0:     static void NotSupported() {
michael@0:         SkDEBUGFAIL("this method should never be called");
michael@0:     }
michael@0: 
michael@0:     static void NothingToDo() {}
michael@0: 
michael@0:     typedef SkBaseDevice INHERITED;
michael@0: };
michael@0: 
michael@0: #endif // SkGatherPixelRefsAndRects_DEFINED