fix windows build; add blend modes

core/fxge/skia/fx_skia_device.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/include/fxge/fx_ge.h"
 
 #if defined(_SKIA_SUPPORT_)
 #include "core/include/fxcodec/fx_codec.h"
 
 #include "core/fxge/agg/fx_agg_driver.h"
 #include "core/fxge/skia/fx_skia_device.h"
 
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkStream.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "third_party/skia/include/effects/SkDashPathEffect.h"
 
+namespace {
+
 #define SHOW_SKIA_PATH 0  // set to 1 to print the path contents
 #define DRAW_SKIA_CLIP 0  // set to 1 to draw a green rectangle around the clip
 
-static void DebugShowSkiaPath(const SkPath& path) {
+void DebugShowSkiaPath(const SkPath& path) {
 #if SHOW_SKIA_PATH
   char buffer[4096];
   sk_bzero(buffer, sizeof(buffer));
   SkMemoryWStream stream(buffer, sizeof(buffer));
   path.dump(&stream, false, false);
   printf("%s\n", buffer);
 #endif  // SHOW_SKIA_PATH
 }
 
-static void DebugShowCanvasMatrix(const SkCanvas* canvas) {
+void DebugShowCanvasMatrix(const SkCanvas* canvas) {
 #if SHOW_SKIA_PATH
   SkMatrix matrix = canvas->getTotalMatrix();
   SkScalar m[9];
   matrix.get9(m);
-  printf("(%g,%g,%g) (%g,%g,%g) (%g,%g,%g)\n", m[0], m[1], m[2], m[3], m[4], m[5], m[6],
-         m[7], m[8]);
+  printf("(%g,%g,%g) (%g,%g,%g) (%g,%g,%g)\n", m[0], m[1], m[2], m[3], m[4],
+         m[5], m[6], m[7], m[8]);
 #endif  // SHOW_SKIA_PATH
 }
 
 #if DRAW_SKIA_CLIP
 
-static SkPaint DebugClipPaint() {
+SkPaint DebugClipPaint() {
   SkPaint paint;
   paint.setAntiAlias(true);
   paint.setColor(SK_ColorGREEN);
   paint.setStyle(SkPaint::kStroke_Style);
   return paint;
 }
 
-static void DebugDrawSkiaClipRect(SkCanvas* canvas, const SkRect& rect) {
+void DebugDrawSkiaClipRect(SkCanvas* canvas, const SkRect& rect) {
   SkPaint paint = DebugClipPaint();
   canvas->drawRect(rect, paint);
 }
 
-static void DebugDrawSkiaClipPath(SkCanvas* canvas, const SkPath& path) {
+void DebugDrawSkiaClipPath(SkCanvas* canvas, const SkPath& path) {
   SkPaint paint = DebugClipPaint();
   canvas->drawPath(path, paint);
 }
 
 #else  // DRAW_SKIA_CLIP
 
-static void DebugDrawSkiaClipRect(SkCanvas* canvas, const SkRect& rect) {}
-static void DebugDrawSkiaClipPath(SkCanvas* canvas, const SkPath& path) {}
+void DebugDrawSkiaClipRect(SkCanvas* canvas, const SkRect& rect) {}
+void DebugDrawSkiaClipPath(SkCanvas* canvas, const SkPath& path) {}
 
 #endif  // DRAW_SKIA_CLIP
 
 #undef SHOW_SKIA_PATH
 #undef DRAW_SKIA_CLIP
 
-static SkPath BuildPath(const CFX_PathData* pPathData) {
+SkPath BuildPath(const CFX_PathData* pPathData) {
   SkPath skPath;
   const CFX_PathData* pFPath = pPathData;
   int nPoints = pFPath->GetPointCount();
   FX_PATHPOINT* pPoints = pFPath->GetPoints();
   for (int i = 0; i < nPoints; i++) {
     FX_FLOAT x = pPoints[i].m_PointX;
     FX_FLOAT y = pPoints[i].m_PointY;
     int point_type = pPoints[i].m_Flag & FXPT_TYPE;
     if (point_type == FXPT_MOVETO) {
       skPath.moveTo(x, y);
     } else if (point_type == FXPT_LINETO) {
       skPath.lineTo(x, y);
     } else if (point_type == FXPT_BEZIERTO) {
       FX_FLOAT x2 = pPoints[i + 1].m_PointX, y2 = pPoints[i + 1].m_PointY;
       FX_FLOAT x3 = pPoints[i + 2].m_PointX, y3 = pPoints[i + 2].m_PointY;
       skPath.cubicTo(x, y, x2, y2, x3, y3);
       i += 2;
     }
     if (pPoints[i].m_Flag & FXPT_CLOSEFIGURE)
       skPath.close();
   }
   return skPath;
 }
 
+SkMatrix ToSkMatrix(const CFX_Matrix& m) {
+  SkMatrix skMatrix;
+  skMatrix.setAll(m.a, m.b, m.e, m.c, m.d, m.f, 0, 0, 1);
+  return skMatrix;
+}
+
+// use when pdf's y-axis points up insead of down
+SkMatrix ToFlippedSkMatrix(const CFX_Matrix& m) {
+  SkMatrix skMatrix;
+  skMatrix.setAll(m.a, m.b, m.e, -m.c, -m.d, m.f, 0, 0, 1);
+  return skMatrix;
+}
+
+SkXfermode::Mode GetSkiaBlendMode(int blend_type) {
+  switch (blend_type) {
+    case FXDIB_BLEND_MULTIPLY:
+      return SkXfermode::kMultiply_Mode;
+    case FXDIB_BLEND_SCREEN:
+      return SkXfermode::kScreen_Mode;
+    case FXDIB_BLEND_OVERLAY:
+      return SkXfermode::kOverlay_Mode;
+    case FXDIB_BLEND_DARKEN:
+      return SkXfermode::kDarken_Mode;
+    case FXDIB_BLEND_LIGHTEN:
+      return SkXfermode::kLighten_Mode;
+    case FXDIB_BLEND_COLORDODGE:
+      return SkXfermode::kColorDodge_Mode;
+    case FXDIB_BLEND_COLORBURN:
+      return SkXfermode::kColorBurn_Mode;
+    case FXDIB_BLEND_HARDLIGHT:
+      return SkXfermode::kHardLight_Mode;
+    case FXDIB_BLEND_SOFTLIGHT:
+      return SkXfermode::kSoftLight_Mode;
+    case FXDIB_BLEND_DIFFERENCE:
+      return SkXfermode::kDifference_Mode;
+    case FXDIB_BLEND_EXCLUSION:
+      return SkXfermode::kExclusion_Mode;
+    case FXDIB_BLEND_HUE:
+      return SkXfermode::kHue_Mode;
+    case FXDIB_BLEND_SATURATION:
+      return SkXfermode::kSaturation_Mode;
+    case FXDIB_BLEND_COLOR:
+      return SkXfermode::kColor_Mode;
+    case FXDIB_BLEND_LUMINOSITY:
+      return SkXfermode::kLuminosity_Mode;
+    case FXDIB_BLEND_NORMAL:
+    default:
+      return SkXfermode::kSrcOver_Mode;
+  }
+}
+
+}  // namespace
+
 // convert a stroking path to scanlines
 void CFX_SkiaDeviceDriver::PaintStroke(SkPaint* spaint,
                                        const CFX_GraphStateData* pGraphState,
                                        const SkMatrix& matrix) {
   SkPaint::Cap cap;
   switch (pGraphState->m_LineCap) {
     case CFX_GraphStateData::LineCapRound:
       cap = SkPaint::kRound_Cap;
       break;
     case CFX_GraphStateData::LineCapSquare:
@@ skipping 15 matching lines @@
       join = SkPaint::kMiter_Join;
       break;
   }
   SkMatrix inverse;
   if (!matrix.invert(&inverse))
     return;  // give up if the matrix is degenerate, and not invertable
   inverse.set(SkMatrix::kMTransX, 0);
   inverse.set(SkMatrix::kMTransY, 0);
   SkVector deviceUnits[2] = {{0, 1}, {1, 0}};
   inverse.mapPoints(deviceUnits, SK_ARRAY_COUNT(deviceUnits));
-  FX_FLOAT width = SkTMax(pGraphState->m_LineWidth,
-                          SkTMin(deviceUnits[0].length(), deviceUnits[1].length()));
+  FX_FLOAT width =
+      SkTMax(pGraphState->m_LineWidth,
+             SkTMin(deviceUnits[0].length(), deviceUnits[1].length()));
   if (pGraphState->m_DashArray) {
     int count = (pGraphState->m_DashCount + 1) / 2;
     SkScalar* intervals = FX_Alloc2D(SkScalar, count, sizeof(SkScalar));
     // Set dash pattern
     for (int i = 0; i < count; i++) {
       FX_FLOAT on = pGraphState->m_DashArray[i * 2];
       if (on <= 0.000001f)
         on = 1.f / 10;
       FX_FLOAT off = i * 2 + 1 == pGraphState->m_DashCount
                          ? on
                          : pGraphState->m_DashArray[i * 2 + 1];
       if (off < 0)
         off = 0;
       intervals[i * 2] = on;
       intervals[i * 2 + 1] = off;
     }
-    spaint->setPathEffect(SkDashPathEffect::Create(intervals, count * 2,
-                                                   pGraphState->m_DashPhase))
-        ->unref();
+    spaint->setPathEffect(
+        SkDashPathEffect::Make(intervals, count * 2, pGraphState->m_DashPhase));
   }
   spaint->setStyle(SkPaint::kStroke_Style);
   spaint->setAntiAlias(true);
   spaint->setStrokeWidth(width);
   spaint->setStrokeMiter(pGraphState->m_MiterLimit);
   spaint->setStrokeCap(cap);
   spaint->setStrokeJoin(join);
 }
 
 CFX_SkiaDeviceDriver::CFX_SkiaDeviceDriver(CFX_DIBitmap* pBitmap,
@@ skipping 30 matching lines @@
   m_pCanvas = m_pRecorder->getRecordingCanvas();
   m_ditherBits = 0;
 }
 
 CFX_SkiaDeviceDriver::~CFX_SkiaDeviceDriver() {
   if (!m_pRecorder)
     delete m_pCanvas;
   delete m_pAggDriver;
 }
 
-static SkMatrix ToSkMatrix(const CFX_Matrix& m) {
-    SkMatrix skMatrix;
-    skMatrix.setAll(m.a, m.b, m.e, m.c, m.d, m.f, 0, 0, 1);
-    return skMatrix;
-}
-
-// use when pdf's y-axis points up insead of down
-static SkMatrix ToFlippedSkMatrix(const CFX_Matrix& m) {
-    SkMatrix skMatrix;
-    skMatrix.setAll(m.a, m.b, m.e, -m.c, -m.d, m.f, 0, 0, 1);
-    return skMatrix;
-}
-
 FX_BOOL CFX_SkiaDeviceDriver::DrawDeviceText(int nChars,
                                              const FXTEXT_CHARPOS* pCharPos,
                                              CFX_Font* pFont,
                                              CFX_FontCache* pCache,
                                              const CFX_Matrix* pObject2Device,
                                              FX_FLOAT font_size,
                                              FX_DWORD color,
                                              int alpha_flag,
                                              void* pIccTransform) {
   SkAutoTUnref<SkTypeface> typeface(SkTypeface::CreateFromStream(
       new SkMemoryStream(pFont->GetFontData(), pFont->GetSize())));
   SkPaint paint;
   paint.setAntiAlias(true);
   paint.setColor(color);
   paint.setTypeface(typeface);
   paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
   paint.setTextSize(font_size);
+  paint.setSubpixelText(true);
   m_pCanvas->save();
   SkMatrix skMatrix = ToFlippedSkMatrix(*pObject2Device);
   m_pCanvas->concat(skMatrix);
   for (int index = 0; index < nChars; ++index) {
     const FXTEXT_CHARPOS& cp = pCharPos[index];
     uint16_t glyph = (uint16_t)cp.m_GlyphIndex;
     m_pCanvas->drawText(&glyph, 2, cp.m_OriginX, cp.m_OriginY, paint);
   }
   m_pCanvas->restore();
   return TRUE;
@@ skipping 92 matching lines @@
     int fill_mode,  // fill mode, WINDING or ALTERNATE. 0 for not filled
     int alpha_flag,
     void* pIccTransform,
     int blend_type) {
   SkIRect rect;
   rect.set(0, 0, GetDeviceCaps(FXDC_PIXEL_WIDTH),
            GetDeviceCaps(FXDC_PIXEL_HEIGHT));
   SkPath skPath = BuildPath(pPathData);
   SkPaint spaint;
   spaint.setAntiAlias(true);
+  spaint.setXfermodeMode(GetSkiaBlendMode(blend_type));
   m_pCanvas->save();
   SkMatrix skMatrix = ToSkMatrix(*pObject2Device);
   m_pCanvas->concat(skMatrix);
   if ((fill_mode & 3) && fill_color) {
     skPath.setFillType((fill_mode & 3) == FXFILL_WINDING
                            ? SkPath::kWinding_FillType
                            : SkPath::kEvenOdd_FillType);
 
     spaint.setStyle(SkPaint::kFill_Style);
     spaint.setColor(fill_color);
@@ skipping 15 matching lines @@
 }
 
 FX_BOOL CFX_SkiaDeviceDriver::FillRect(const FX_RECT* pRect,
                                        FX_DWORD fill_color,
                                        int alpha_flag,
                                        void* pIccTransform,
                                        int blend_type) {
   SkPaint spaint;
   spaint.setAntiAlias(true);
   spaint.setColor(fill_color);
+  spaint.setXfermodeMode(GetSkiaBlendMode(blend_type));
 
   m_pCanvas->drawRect(
       SkRect::MakeLTRB(pRect->left, pRect->top, pRect->right, pRect->bottom),
       spaint);
   return TRUE;
 }
 
 FX_BOOL CFX_SkiaDeviceDriver::GetClipBox(FX_RECT* pRect) {
   // TODO(caryclark) call m_canvas->getClipDeviceBounds() instead
   pRect->left = 0;
@@ skipping 113 matching lines @@
   const CFX_Matrix& m = *pMatrix;
   // note that PDF's y-axis goes up; Skia's y-axis goes down
   if (landscape)
     skMatrix.setAll(-m.a, -m.b, m.e, m.c, m.d, m.f, 0, 0, 1);
   else
     skMatrix.setAll(m.a, m.b, 0, -m.c, -m.d, 0, 0, 0, 1);
   m_pCanvas->concat(skMatrix);
   SkPaint paint;
   paint.setAntiAlias(true);
   paint.setFilterQuality(kHigh_SkFilterQuality);
+  paint.setXfermodeMode(GetSkiaBlendMode(blend_type));
+  paint.setAlpha(bitmap_alpha);
   m_pCanvas->drawBitmap(skBitmap, 0, 0, &paint);
   m_pCanvas->restore();
   return TRUE;
 }
 
 FX_BOOL CFX_SkiaDeviceDriver::ContinueDIBits(void* pHandle, IFX_Pause* pPause) {
   return m_pAggDriver && m_pAggDriver->ContinueDIBits(pHandle, pPause);
 }
 
 void CFX_SkiaDeviceDriver::CancelDIBits(void* pHandle) {
@@ skipping 48 matching lines @@
   SetDeviceDriver(pDriver);
   return TRUE;
 }
 
 CFX_SkiaDevice::~CFX_SkiaDevice() {
   if (m_bOwnedBitmap && GetBitmap())
     delete GetBitmap();
 }
 
 #endif