Inverse fill support in PDF

src/pdf/SkPDFDevice.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 "SkPDFDevice.h"
 
 #include "SkAnnotation.h"
 #include "SkColor.h"
 #include "SkClipStack.h"
 #include "SkData.h"
 #include "SkDraw.h"
 #include "SkFontHost.h"
 #include "SkGlyphCache.h"
 #include "SkPaint.h"
 #include "SkPath.h"
+#include "SkPathOps.h"
 #include "SkPDFFont.h"
 #include "SkPDFFormXObject.h"
 #include "SkPDFGraphicState.h"
 #include "SkPDFImage.h"
 #include "SkPDFResourceDict.h"
 #include "SkPDFShader.h"
 #include "SkPDFStream.h"
 #include "SkPDFTypes.h"
 #include "SkPDFUtils.h"
 #include "SkRect.h"
@@ skipping 790 matching lines @@
             }
         }
     }
 
     if (paint.getPathEffect()) {
         if (d.fClip->isEmpty()) {
             return;
         }
         if (!pathIsMutable) {
             pathPtr = &modifiedPath;
-            pathIsMutable = true;

[ducky, 2013/07/25 03:32:20]

This code really doesn't do anything (I think, at least), so I cleaned it out.

         }
         bool fill = paint.getFillPath(origPath, pathPtr);
 
         SkPaint noEffectPaint(paint);
         noEffectPaint.setPathEffect(NULL);
         if (fill) {
             noEffectPaint.setStyle(SkPaint::kFill_Style);
         } else {
             noEffectPaint.setStyle(SkPaint::kStroke_Style);
             noEffectPaint.setStrokeWidth(0);
         }
         drawPath(d, *pathPtr, noEffectPaint, NULL, true);
         return;
     }
 
+    // TODO(richardlin): This doesn't handle inverse stroke (line) operations.
+    // Related to Issue 241.
+    if (origPath.isInverseFillType()) {
+        if (d.fClip->isEmpty()) {
+            return;
+        }
+        if (!pathIsMutable) {
+            pathPtr = &modifiedPath;
+        }
+
+        // Get bounds of clip in current transform space
+        // (clip bounds are given in device space).
+        SkRect bounds;
+        SkMatrix transformInverse;
+        if (!d.fMatrix->invert(&transformInverse)) {
+            return;
+        }
+        bounds.set(d.fClip->getBounds());
+        transformInverse.mapRect(&bounds);
+
+        // Extend the bounds by the line width, so the edge doesn't cause
+        // a visible stroke.
+        SkScalar lineWidth = paint.getStrokeWidth();
+        bounds = SkRect::MakeLTRB(
+                bounds.left() - lineWidth, bounds.top() - lineWidth,
+                bounds.right() + lineWidth, bounds.bottom() + lineWidth);
+
+        SkPath fillPath;
+        fillPath.addRect(bounds);
+
+        // Create positive version of original path, since PathOps takes
+        // inverse fills into account.
+        SkPath origDup(origPath);
+        origDup.toggleInverseFillType();
+
+        if (Op(fillPath, origDup, kDifference_PathOp, pathPtr)) {
+            drawPath(d, *pathPtr, paint, NULL, true);
+        }
+        return;
+    }
+
     if (handleRectAnnotation(pathPtr->getBounds(), *d.fMatrix, paint)) {
         return;
     }
 
     ScopedContentEntry content(this, d, paint);
     if (!content.entry()) {
         return;
     }
     SkPDFUtils::EmitPath(*pathPtr, paint.getStyle(),
                          &content.entry()->fContent);
@@ skipping 898 matching lines @@
 }
 
 bool SkPDFDevice::onReadPixels(const SkBitmap& bitmap, int x, int y,
                                SkCanvas::Config8888) {
     return false;
 }
 
 bool SkPDFDevice::allowImageFilter(SkImageFilter*) {
     return false;
 }