WIP -- separate out Parts from SkPaint

src/core/SkPaint.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 "SkPaint.h"
 #include "SkAnnotation.h"
@@ skipping 17 matching lines @@
 #include "SkScalerContext.h"
 #include "SkShader.h"
 #include "SkStringUtils.h"
 #include "SkStroke.h"
 #include "SkTextFormatParams.h"
 #include "SkTextToPathIter.h"
 #include "SkTLazy.h"
 #include "SkTypeface.h"
 #include "SkXfermode.h"
 
+bool SkPaintParts::operator==(const SkPaintParts& other) const {

[mtklein, 2014/04/15 14:32:44]

Give him his own .cpp?

[reed1, 2014/04/18 14:04:31]

Eventually yes.

+#define EQUAL(field) (this->field == other.field)
+    return EQUAL(fTypeface)
+        && EQUAL(fPathEffect)
+        && EQUAL(fShader)
+        && EQUAL(fXfermode)
+        && EQUAL(fMaskFilter)
+        && EQUAL(fColorFilter)
+        && EQUAL(fRasterizer)
+        && EQUAL(fLooper)
+        && EQUAL(fImageFilter)
+        && EQUAL(fAnnotation)
+        && EQUAL(fTextSize)
+        && EQUAL(fTextScaleX)
+        && EQUAL(fTextSkewX)
+        && EQUAL(fColor)
+        && EQUAL(fWidth)
+        && EQUAL(fMiterLimit)
+        && EQUAL(fBitfields)
+        ;
+#undef EQUAL
+}
+
+///////////
+
+
 enum {
     kColor_DirtyBit               = 1 <<  0,
     kBitfields_DirtyBit           = 1 <<  1,
     kTextSize_DirtyBit            = 1 <<  2,
     kTextScaleX_DirtyBit          = 1 <<  3,
     kTextSkewX_DirtyBit           = 1 <<  4,
     kStrokeWidth_DirtyBit         = 1 <<  5,
     kStrokeMiter_DirtyBit         = 1 <<  6,
     kPathEffect_DirtyBit          = 1 <<  7,
     kShader_DirtyBit              = 1 <<  8,
@@ skipping 14 matching lines @@
 
 #ifdef SK_BUILD_FOR_ANDROID
 #define GEN_ID_INC                  fGenerationID++
 #define GEN_ID_INC_EVAL(expression) if (expression) { fGenerationID++; }
 #else
 #define GEN_ID_INC
 #define GEN_ID_INC_EVAL(expression)
 #endif
 
 SkPaint::SkPaint() {
-    fTypeface    = NULL;
-    fPathEffect  = NULL;
-    fShader      = NULL;
-    fXfermode    = NULL;
-    fMaskFilter  = NULL;
-    fColorFilter = NULL;
-    fRasterizer  = NULL;
-    fLooper      = NULL;
-    fImageFilter = NULL;
-    fAnnotation  = NULL;
+    // set any non-zero values in fParts
 
-    fTextSize     = SkPaintDefaults_TextSize;
-    fTextScaleX   = SK_Scalar1;
-    fTextSkewX    = 0;
-    fColor        = SK_ColorBLACK;
-    fWidth        = 0;
-    fMiterLimit   = SkPaintDefaults_MiterLimit;
+    fParts.fTextSize     = SkPaintDefaults_TextSize;
+    fParts.fTextScaleX   = SK_Scalar1;
+    fParts.fColor        = SK_ColorBLACK;
+    fParts.fMiterLimit   = SkPaintDefaults_MiterLimit;
 
-    // Zero all bitfields, then set some non-zero defaults.
-    fBitfields    = 0;
-    fFlags        = SkPaintDefaults_Flags;
-    fCapType      = kDefault_Cap;
-    fJoinType     = kDefault_Join;
-    fTextAlign    = kLeft_Align;
-    fStyle        = kFill_Style;
-    fTextEncoding = kUTF8_TextEncoding;
-    fHinting      = SkPaintDefaults_Hinting;
+    fParts.fFlags        = SkPaintDefaults_Flags;
+    fParts.fCapType      = SkPaintParts::kDefault_Cap;
+    fParts.fJoinType     = SkPaintParts::kDefault_Join;
+    fParts.fTextAlign    = SkPaintParts::kLeft_Align;
+    fParts.fStyle        = SkPaintParts::kFill_Style;
+    fParts.fTextEncoding = kUTF8_TextEncoding;
+    fParts.fHinting      = SkPaintDefaults_Hinting;
 
     fDirtyBits    = 0;
 #ifdef SK_BUILD_FOR_ANDROID
     new (&fPaintOptionsAndroid) SkPaintOptionsAndroid;
     fGenerationID = 0;
 #endif
 }
 
 SkPaint::SkPaint(const SkPaint& src) {
-#define COPY(field) field = src.field
-#define REF_COPY(field) field = SkSafeRef(src.field)
+#define COPY(field) fParts.field = src.fParts.field
+#define REF_COPY(field) fParts.field = SkSafeRef(src.fParts.field)
 

[tomhudson, 2014/04/16 11:41:31]

operator= asserts that the argument isn't *(NULL). Is that worth doing here?

     REF_COPY(fTypeface);
     REF_COPY(fPathEffect);
     REF_COPY(fShader);
     REF_COPY(fXfermode);
     REF_COPY(fMaskFilter);
     REF_COPY(fColorFilter);
     REF_COPY(fRasterizer);
     REF_COPY(fLooper);
     REF_COPY(fImageFilter);
     REF_COPY(fAnnotation);
 
     COPY(fTextSize);
     COPY(fTextScaleX);
     COPY(fTextSkewX);
     COPY(fColor);
     COPY(fWidth);
     COPY(fMiterLimit);
     COPY(fBitfields);
-    COPY(fDirtyBits);
+
+    fDirtyBits = src.fDirtyBits;
 
 #ifdef SK_BUILD_FOR_ANDROID
     new (&fPaintOptionsAndroid) SkPaintOptionsAndroid(src.fPaintOptionsAndroid);
     COPY(fGenerationID);
 #endif
 
 #undef COPY
 #undef REF_COPY
 }
 
 SkPaint::~SkPaint() {
-    SkSafeUnref(fTypeface);
-    SkSafeUnref(fPathEffect);
-    SkSafeUnref(fShader);
-    SkSafeUnref(fXfermode);
-    SkSafeUnref(fMaskFilter);
-    SkSafeUnref(fColorFilter);
-    SkSafeUnref(fRasterizer);
-    SkSafeUnref(fLooper);
-    SkSafeUnref(fImageFilter);
-    SkSafeUnref(fAnnotation);
+    SkSafeUnref(fParts.fTypeface);
+    SkSafeUnref(fParts.fPathEffect);
+    SkSafeUnref(fParts.fShader);
+    SkSafeUnref(fParts.fXfermode);
+    SkSafeUnref(fParts.fMaskFilter);
+    SkSafeUnref(fParts.fColorFilter);
+    SkSafeUnref(fParts.fRasterizer);
+    SkSafeUnref(fParts.fLooper);
+    SkSafeUnref(fParts.fImageFilter);
+    SkSafeUnref(fParts.fAnnotation);
 }
 
 SkPaint& SkPaint::operator=(const SkPaint& src) {
-#define COPY(field) field = src.field
-#define REF_COPY(field) SkSafeUnref(field); field = SkSafeRef(src.field)
+#define COPY(field) fParts.field = src.fParts.field
+#define REF_COPY(field) SkSafeUnref(fParts.field); fParts.field = SkSafeRef(src.fParts.field)
 
     SkASSERT(&src);
 
     REF_COPY(fTypeface);
     REF_COPY(fPathEffect);
     REF_COPY(fShader);
     REF_COPY(fXfermode);
     REF_COPY(fMaskFilter);
     REF_COPY(fColorFilter);
     REF_COPY(fRasterizer);
     REF_COPY(fLooper);
     REF_COPY(fImageFilter);
     REF_COPY(fAnnotation);
 
     COPY(fTextSize);
     COPY(fTextScaleX);
     COPY(fTextSkewX);
     COPY(fColor);
     COPY(fWidth);
     COPY(fMiterLimit);
     COPY(fBitfields);
-    COPY(fDirtyBits);
+    
+    fDirtyBits = src.fDirtyBits;
 
 #ifdef SK_BUILD_FOR_ANDROID
     fPaintOptionsAndroid.~SkPaintOptionsAndroid();
     new (&fPaintOptionsAndroid) SkPaintOptionsAndroid(src.fPaintOptionsAndroid);
     ++fGenerationID;
 #endif
 
     return *this;
 
 #undef COPY
 #undef REF_COPY
 }
 
 bool operator==(const SkPaint& a, const SkPaint& b) {
-#define EQUAL(field) (a.field == b.field)
-    // Don't check fGenerationID or fDirtyBits, which can be different for logically equal paints.
-    return EQUAL(fTypeface)
-        && EQUAL(fPathEffect)
-        && EQUAL(fShader)
-        && EQUAL(fXfermode)
-        && EQUAL(fMaskFilter)
-        && EQUAL(fColorFilter)
-        && EQUAL(fRasterizer)
-        && EQUAL(fLooper)
-        && EQUAL(fImageFilter)
-        && EQUAL(fAnnotation)
-        && EQUAL(fTextSize)
-        && EQUAL(fTextScaleX)
-        && EQUAL(fTextSkewX)
-        && EQUAL(fColor)
-        && EQUAL(fWidth)
-        && EQUAL(fMiterLimit)
-        && EQUAL(fBitfields)
+    if (a.fParts != b.fParts) {
+        return false;
+    }
 #ifdef SK_BUILD_FOR_ANDROID
-        && EQUAL(fPaintOptionsAndroid)
+    if (fPaintOptionsAndroid != b.fPaintOptionsAndroid) {

[mtklein, 2014/04/15 14:32:44]

It makes me very happy that these are not moving into SkPaintParts.

+        return false;
+    }
 #endif
-        ;
-#undef EQUAL
+    return true;
 }
 
 void SkPaint::reset() {
     SkPaint init;
 
 #ifdef SK_BUILD_FOR_ANDROID
     uint32_t oldGenerationID = fGenerationID;
 #endif
     *this = init;
 #ifdef SK_BUILD_FOR_ANDROID
@@ skipping 2458 matching lines @@
     }
 #ifdef SK_BUILD_FOR_ANDROID
     if (dirty & kPaintOptionsAndroid_DirtyBit) {
         SkPaintOptionsAndroid options;
         options.unflatten(buffer);
         paint->setPaintOptionsAndroid(options);
     }
 #endif
     SkASSERT(dirty == paint->fDirtyBits);
 }