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 806 matching lines @@
         if (fill) {
             noEffectPaint.setStyle(SkPaint::kFill_Style);
         } else {
             noEffectPaint.setStyle(SkPaint::kStroke_Style);
             noEffectPaint.setStrokeWidth(0);
         }
         drawPath(d, *pathPtr, noEffectPaint, NULL, true);
         return;
     }
 
+#ifdef SK_PDF_USE_PATHOPS
+    if (origPath.isInverseFillType()) {

[vandebo (ex-Chrome), 2013/07/30 16:50:42]

nit: Push this into the handle method...

if (handleInversePath(...)) {
    return;
}

[ducky, 2013/07/30 22:01:55]

Done.

+        handleInversePath(d, origPath, paint, pathIsMutable);
+        return;
+    }
+#endif
+
     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 370 matching lines @@
         emit_clip(NULL, &r, &data);
     }
 
     SkPDFDevice::copyContentEntriesToData(fContentEntries.get(), &data);
 
     // potentially we could cache this SkData, and only rebuild it if we
     // see that our state has changed.
     return data.copyToData();
 }
 
+/* Calculate an inverted path's equivalent non-inverted path, given the
+ * canvas bounds.
+ */
+bool calculate_inverse_path(const SkRect& bounds, const SkPath& invPath,

[vandebo (ex-Chrome), 2013/07/30 16:50:42]

You can inline this function unless you intend to reuse it for something else.

[ducky, 2013/07/30 22:01:55]

I probably should have noted that this was to get re-used in the upcoming Path
Ops clips GM.

+                            SkPath* outPath) {
+    SkASSERT(invPath.isInverseFillType());
+
+    SkPath clipPath;
+    clipPath.addRect(bounds);
+
+    return Op(clipPath, invPath, kIntersect_PathOp, outPath);
+}
+
+/* Draws an inverse filled path by using Path Ops to compute the positive
+ * inverse using the current clip as the inverse bounds.
+ */
+void SkPDFDevice::handleInversePath(const SkDraw& d, const SkPath& origPath,
+                                    const SkPaint& paint, bool pathIsMutable) {
+    SkASSERT(origPath.isInverseFillType());
+
+    if (d.fClip->isEmpty()) {
+        return;
+    }
+
+    SkPath modifiedPath;
+    SkPath* pathPtr = const_cast<SkPath*>(&origPath);
+    SkPaint noInversePaint(paint);
+
+    // Merge stroking operations into final path.
+    if (SkPaint::kStroke_Style == paint.getStyle() ||
+        SkPaint::kStrokeAndFill_Style == paint.getStyle()) {
+        pathPtr = &modifiedPath;
+        if (paint.getFillPath(origPath, pathPtr)) {
+            noInversePaint.setStyle(SkPaint::kFill_Style);
+            noInversePaint.setStrokeWidth(0);
+        } else {
+            // To be consistent with the raster output, hairline strokes

[vandebo (ex-Chrome), 2013/07/30 16:50:42]

At this point pathPtr points to modifiedPath that is default constructed.

[ducky, 2013/07/30 22:01:55]

I think paint.getFillPath still duplicates the paint into pathPtr. Though I can
see how the style could be confusing, so I'll clarify it.
In either case, the GMs seem to come out sane.

+            // are rendered as non-inverted.
+            pathPtr->toggleInverseFillType();
+            drawPath(d, *pathPtr, paint, NULL, true);
+            return;

[vandebo (ex-Chrome), 2013/07/30 16:50:42]

After you've changed this to return a bool though, you can just return false and
have the rest of the path code handle it without needing to toggle the inverse
fill bit.

[ducky, 2013/07/30 22:01:55]

I can see how that would be faster, but it seems less clean in that an inverse
path would continue down drawPath. It also seems like the required overhead is
minimal - just one function call, since I think getFillPath does a copy
regardless.

+        }
+    }
+
+    // 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 (plus some padding)
+    // so the edge doesn't cause a visible stroke.
+    bounds.outset(paint.getStrokeWidth() + SK_Scalar1,
+                  paint.getStrokeWidth() + SK_Scalar1);
+
+    if (calculate_inverse_path(bounds, *pathPtr, &modifiedPath)) {
+        drawPath(d, modifiedPath, noInversePaint, NULL, true);
+    }
+}
+
 bool SkPDFDevice::handleRectAnnotation(const SkRect& r, const SkMatrix& matrix,
                                        const SkPaint& p) {
     SkAnnotation* annotationInfo = p.getAnnotation();
     if (!annotationInfo) {
         return false;
     }
     SkData* urlData = annotationInfo->find(SkAnnotationKeys::URL_Key());
     if (urlData) {
         handleLinkToURL(urlData, r, matrix);
         return p.isNoDrawAnnotation();
@@ skipping 506 matching lines @@
 }
 
 bool SkPDFDevice::onReadPixels(const SkBitmap& bitmap, int x, int y,
                                SkCanvas::Config8888) {
     return false;
 }
 
 bool SkPDFDevice::allowImageFilter(SkImageFilter*) {
     return false;
 }