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"
@@ skipping 19 matching lines @@
   path.dump(&stream, false, false);
   printf("%s\n", buffer);
 #endif  // SHOW_SKIA_PATH
 }
 
 static 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 paint;
   paint.setAntiAlias(true);
   paint.setColor(SK_ColorGREEN);
   paint.setStyle(SkPaint::kStroke_Style);
@@ skipping 38 matching lines @@
       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;
 }
 
+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;
+}
+
+static 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;
+  }
+}
+
 // 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
@@ skipping 49 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(
@@ skipping 109 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));
   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