Add printing of SkColorFilter-derived classes to debugger

src/effects/SkColorFilters.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkBlitRow.h"
 #include "SkColorFilter.h"
 #include "SkColorPriv.h"
 #include "SkFlattenableBuffers.h"
 #include "SkUtils.h"
+#include "SkString.h"
 
 #define ILLEGAL_XFERMODE_MODE   ((SkXfermode::Mode)-1)
 
 // baseclass for filters that store a color and mode
 class SkModeColorFilter : public SkColorFilter {
 public:
     SkModeColorFilter(SkColor color) {
         fColor = color;
         fMode = ILLEGAL_XFERMODE_MODE;
         this->updateCache();
@@ skipping 43 matching lines @@
         SkASSERT(this->getFlags() & kHasFilter16_Flag);
 
         SkPMColor        color = fPMColor;
         SkXfermodeProc16 proc16 = fProc16;
 
         for (int i = 0; i < count; i++) {
             result[i] = proc16(color, shader[i]);
         }
     }
 
+#ifdef SK_DEVELOPER
+    virtual void toString(SkString* str) const SK_OVERRIDE {
+        str->append("SkModeColorFilter: color: 0x");
+        str->appendHex(fColor);
+        str->append(" mode: ");
+        str->append(SkXfermode::ModeName(fMode));
+    }
+#endif
+
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkModeColorFilter)
 
 protected:
     virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE {
         this->INHERITED::flatten(buffer);
         buffer.writeColor(fColor);
         buffer.writeUInt(fMode);
     }
 
     SkModeColorFilter(SkFlattenableReadBuffer& buffer) {
@@ skipping 165 matching lines @@
                 unsigned scaleA = SkAlpha255To256(a);
                 unsigned r = pin(SkAlphaMul(SkGetPackedR32(c), scaleR) + SkAlphaMul(addR, scaleA), a);
                 unsigned g = pin(SkAlphaMul(SkGetPackedG32(c), scaleG) + SkAlphaMul(addG, scaleA), a);
                 unsigned b = pin(SkAlphaMul(SkGetPackedB32(c), scaleB) + SkAlphaMul(addB, scaleA), a);
                 c = SkPackARGB32(a, r, g, b);
             }
             result[i] = c;
         }
     }
 
+#ifdef SK_DEVELOPER
+    virtual void toString(SkString* str) const SK_OVERRIDE {
+        str->append("SkLightingColorFilter: mul: 0x");
+        str->appendHex(fMul);
+        str->append(" add: 0x");
+        str->appendHex(fAdd);
+    }
+#endif
+
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLightingColorFilter)
 
 protected:
     virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE {
         this->INHERITED::flatten(buffer);
         buffer.writeColor(fMul);
         buffer.writeColor(fAdd);
     }
 
     SkLightingColorFilter(SkFlattenableReadBuffer& buffer) {
@@ skipping 25 matching lines @@
                 unsigned scaleA = SkAlpha255To256(a);
                 unsigned r = pin(SkGetPackedR32(c) + SkAlphaMul(addR, scaleA), a);
                 unsigned g = pin(SkGetPackedG32(c) + SkAlphaMul(addG, scaleA), a);
                 unsigned b = pin(SkGetPackedB32(c) + SkAlphaMul(addB, scaleA), a);
                 c = SkPackARGB32(a, r, g, b);
             }
             result[i] = c;
         }
     }
 
+#ifdef SK_DEVELOPER
+    virtual void toString(SkString* str) const SK_OVERRIDE {
+        str->append("SkLightingColorFilter_JustAdd: add: 0x");
+        str->appendHex(fAdd);
+    }
+#endif
+
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLightingColorFilter_JustAdd)
 
 protected:
     SkLightingColorFilter_JustAdd(SkFlattenableReadBuffer& buffer)
         : INHERITED(buffer) {}
 
 private:
     typedef SkLightingColorFilter INHERITED;
 };
 
@@ skipping 14 matching lines @@
                 unsigned a = SkGetPackedA32(c);
                 unsigned r = SkAlphaMul(SkGetPackedR32(c), scaleR);
                 unsigned g = SkAlphaMul(SkGetPackedG32(c), scaleG);
                 unsigned b = SkAlphaMul(SkGetPackedB32(c), scaleB);
                 c = SkPackARGB32(a, r, g, b);
             }
             result[i] = c;
         }
     }
 
+#ifdef SK_DEVELOPER
+    virtual void toString(SkString* str) const SK_OVERRIDE {
+        str->append("SkLightingColorFilter_JustMul: mul: 0x");
+        str->appendHex(fMul);
+    }
+#endif
+
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLightingColorFilter_JustMul)
 
 protected:
     SkLightingColorFilter_JustMul(SkFlattenableReadBuffer& buffer)
         : INHERITED(buffer) {}
 
 private:
     typedef SkLightingColorFilter INHERITED;
 };
 
@@ skipping 17 matching lines @@
         // all mul components are the same
         unsigned scale = SkAlpha255To256(SkColorGetR(fMul));
 
         if (count > 0) {
             do {
                 *result++ = SkAlphaMulRGB16(*shader++, scale);
             } while (--count > 0);
         }
     }
 
+#ifdef SK_DEVELOPER
+    virtual void toString(SkString* str) const SK_OVERRIDE {
+        str->append("SkLightingColorFilter_SingleMul: mul: 0x");
+        str->appendHex(fMul);
+    }
+#endif
+
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLightingColorFilter_SingleMul)
 
 protected:
     SkLightingColorFilter_SingleMul(SkFlattenableReadBuffer& buffer)
         : INHERITED(buffer) {}
 
 private:
     typedef SkLightingColorFilter INHERITED;
 };
 
@@ skipping 19 matching lines @@
                 unsigned scaleA = SkAlpha255To256(a);
                 unsigned r = SkAlphaMul(SkGetPackedR32(c), scaleR) + SkAlphaMul(addR, scaleA);
                 unsigned g = SkAlphaMul(SkGetPackedG32(c), scaleG) + SkAlphaMul(addG, scaleA);
                 unsigned b = SkAlphaMul(SkGetPackedB32(c), scaleB) + SkAlphaMul(addB, scaleA);
                 c = SkPackARGB32(a, r, g, b);
             }
             result[i] = c;
         }
     }
 
+#ifdef SK_DEVELOPER
+    virtual void toString(SkString* str) const SK_OVERRIDE {
+        str->append("SkLightingColorFilter_NoPin: mul: 0x");
+        str->appendHex(fMul);
+        str->append(" add: 0x");
+        str->appendHex(fAdd);
+    }
+#endif
+
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLightingColorFilter_NoPin)
 
 protected:
     SkLightingColorFilter_NoPin(SkFlattenableReadBuffer& buffer)
         : INHERITED(buffer) {}
 
 private:
     typedef SkLightingColorFilter INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class SkSimpleColorFilter : public SkColorFilter {
 public:
     static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
         return SkNEW(SkSimpleColorFilter);
     }
 
+#ifdef SK_DEVELOPER
+    virtual void toString(SkString* str) const SK_OVERRIDE {
+        str->append("SkSimpleColorFilter");
+    }
+#endif
+
 protected:
     void filterSpan(const SkPMColor src[], int count, SkPMColor
                     result[]) const SK_OVERRIDE {
         if (result != src) {
             memcpy(result, src, count * sizeof(SkPMColor));
         }
     }
 
     virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE {}
 
@@ skipping 37 matching lines @@
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkModeColorFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(Src_SkModeColorFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SrcOver_SkModeColorFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingColorFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingColorFilter_JustAdd)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingColorFilter_JustMul)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingColorFilter_SingleMul)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingColorFilter_NoPin)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSimpleColorFilter)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END