[WIP] Add Context to SkDrawLooper.

src/effects/SkLayerDrawLooper.cpp

 
 /*
  * 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 "SkCanvas.h"
 #include "SkColor.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkLayerDrawLooper.h"
 #include "SkString.h"
 #include "SkStringUtils.h"
+#include "SkTemplatesPriv.h"
 #include "SkUnPreMultiply.h"
 
 SkLayerDrawLooper::LayerInfo::LayerInfo() {
     fFlagsMask = 0;                     // ignore our paint flags
     fPaintBits = 0;                     // ignore our paint fields
     fColorMode = SkXfermode::kDst_Mode; // ignore our color
     fOffset.set(0, 0);
     fPostTranslate = false;
 }
 
 SkLayerDrawLooper::SkLayerDrawLooper()
         : fRecs(NULL),
           fTopRec(NULL),
-          fCount(0),
-          fCurrRec(NULL) {
+          fCount(0) {
 }
 
 SkLayerDrawLooper::~SkLayerDrawLooper() {
     Rec* rec = fRecs;
     while (rec) {
         Rec* next = rec->fNext;
         SkDELETE(rec);
         rec = next;
     }
 }
@@ skipping 29 matching lines @@
         fRecs = rec;
     } else {
         SkASSERT(NULL != fTopRec);
         fTopRec->fNext = rec;
     }
     fTopRec = rec;
 
     return &rec->fPaint;
 }
 
-void SkLayerDrawLooper::init(SkCanvas* canvas) {
-    fCurrRec = fRecs;
+SkLayerDrawLooper::DrawContext* SkLayerDrawLooper::init(
+        SkCanvas* canvas, void* storage, size_t storageSize) const {
+    LayerDrawLooperContext* context;
+    SK_PLACEMENT_SAFE_NEW_ARGS(context, LayerDrawLooperContext, storage,
+                               storageSize, (this));
     canvas->save(SkCanvas::kMatrix_SaveFlag);
+    return context;
 }
 
 static SkColor xferColor(SkColor src, SkColor dst, SkXfermode::Mode mode) {
     switch (mode) {
         case SkXfermode::kSrc_Mode:
             return src;
         case SkXfermode::kDst_Mode:
             return dst;
         default: {
             SkPMColor pmS = SkPreMultiplyColor(src);
             SkPMColor pmD = SkPreMultiplyColor(dst);
             SkPMColor result = SkXfermode::GetProc(mode)(pmS, pmD);
             return SkUnPreMultiply::PMColorToColor(result);
         }
     }
 }
 
 // Even with kEntirePaint_Bits, we always ensure that the master paint's
 // text-encoding is respected, since that controls how we interpret the
 // text/length parameters of a draw[Pos]Text call.
-void SkLayerDrawLooper::ApplyInfo(SkPaint* dst, const SkPaint& src,
-                                  const LayerInfo& info) {
+void SkLayerDrawLooper::LayerDrawLooperContext::ApplyInfo(
+        SkPaint* dst, const SkPaint& src, const LayerInfo& info) {
 
     uint32_t mask = info.fFlagsMask;
     dst->setFlags((dst->getFlags() & ~mask) | (src.getFlags() & mask));
     dst->setColor(xferColor(src.getColor(), dst->getColor(), info.fColorMode));
 
     BitFlags bits = info.fPaintBits;
     SkPaint::TextEncoding encoding = dst->getTextEncoding();
 
     if (0 == bits) {
         return;
@@ skipping 49 matching lines @@
 #endif
 }
 
 // Should we add this to canvas?
 static void postTranslate(SkCanvas* canvas, SkScalar dx, SkScalar dy) {
     SkMatrix m = canvas->getTotalMatrix();
     m.postTranslate(dx, dy);
     canvas->setMatrix(m);
 }
 
-bool SkLayerDrawLooper::next(SkCanvas* canvas, SkPaint* paint) {
+SkLayerDrawLooper::LayerDrawLooperContext::LayerDrawLooperContext(
+        const SkLayerDrawLooper* looper) : fCurrRec(looper->fRecs) {}
+
+bool SkLayerDrawLooper::LayerDrawLooperContext::next(SkCanvas* canvas,
+                                                     SkPaint* paint) {
     canvas->restore();
     if (NULL == fCurrRec) {
         return false;
     }
 
     ApplyInfo(paint, fCurrRec->fPaint, fCurrRec->fInfo);
 
     canvas->save(SkCanvas::kMatrix_SaveFlag);
     if (fCurrRec->fInfo.fPostTranslate) {
         postTranslate(canvas, fCurrRec->fInfo.fOffset.fX,
                       fCurrRec->fInfo.fOffset.fY);
     } else {
-        canvas->translate(fCurrRec->fInfo.fOffset.fX, fCurrRec->fInfo.fOffset.fY);
+        canvas->translate(fCurrRec->fInfo.fOffset.fX,
+                          fCurrRec->fInfo.fOffset.fY);
     }
     fCurrRec = fCurrRec->fNext;
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkLayerDrawLooper::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
@@ skipping 21 matching lines @@
         buffer.writeBool(rec->fInfo.fPostTranslate);
         buffer.writePaint(rec->fPaint);
         rec = rec->fNext;
     }
 }
 
 SkLayerDrawLooper::SkLayerDrawLooper(SkReadBuffer& buffer)
         : INHERITED(buffer),
           fRecs(NULL),
           fTopRec(NULL),
-          fCount(0),
-          fCurrRec(NULL) {
+          fCount(0) {
     int count = buffer.readInt();
 
     for (int i = 0; i < count; i++) {
         LayerInfo info;
         info.fFlagsMask = buffer.readInt();
         info.fPaintBits = buffer.readInt();
         info.fColorMode = (SkXfermode::Mode)buffer.readInt();
         buffer.readPoint(&info.fOffset);
         info.fPostTranslate = buffer.readBool();
         buffer.readPaint(this->addLayerOnTop(info));
@@ skipping 100 matching lines @@
             str->append("true ");
         } else {
             str->append("false ");
         }
 
         rec->fPaint.toString(str);
         rec = rec->fNext;
     }
 }
 #endif