src/skia/ext/vector_platform_device_emf_win.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "skia/ext/vector_platform_device_emf_win.h"
   6
   7 #include <windows.h>
   8
   9 #include "base/logging.h"
  10 #include "base/strings/string16.h"
  11 #include "skia/ext/bitmap_platform_device.h"
  12 #include "skia/ext/skia_utils_win.h"
  13 #include "third_party/skia/include/core/SkFontHost.h"
  14 #include "third_party/skia/include/core/SkPathEffect.h"
  15 #include "third_party/skia/include/core/SkTemplates.h"
  16 #include "third_party/skia/include/core/SkUtils.h"
  17 #include "third_party/skia/include/ports/SkTypeface_win.h"
  18
  19 namespace skia {
  20
  21 #define CHECK_FOR_NODRAW_ANNOTATION(paint) \
  22     do { if (paint.isNoDrawAnnotation()) { return; } } while (0)
  23
  24 // static
  25 SkBaseDevice* VectorPlatformDeviceEmf::CreateDevice(
  26     int width, int height, bool is_opaque, HANDLE shared_section) {
  27   if (!is_opaque) {
  28     // TODO(maruel):  http://crbug.com/18382 When restoring a semi-transparent
  29     // layer, i.e. merging it, we need to rasterize it because GDI doesn't
  30     // support transparency except for AlphaBlend(). Right now, a
  31     // BitmapPlatformDevice is created when VectorCanvas think a saveLayers()
  32     // call is being done. The way to save a layer would be to create an
  33     // EMF-based VectorDevice and have this device registers the drawing. When
  34     // playing back the device into a bitmap, do it at the printer's dpi instead
  35     // of the layout's dpi (which is much lower).
  36     return BitmapPlatformDevice::Create(width, height, is_opaque,
  37                                         shared_section);
  38   }
  39
  40   // TODO(maruel):  http://crbug.com/18383 Look if it would be worth to
  41   // increase the resolution by ~10x (any worthy factor) to increase the
  42   // rendering precision (think about printing) while using a relatively
  43   // low dpi. This happens because we receive float as input but the GDI
  44   // functions works with integers. The idea is to premultiply the matrix
  45   // with this factor and multiply each SkScalar that are passed to
  46   // SkScalarRound(value) as SkScalarRound(value * 10). Safari is already
  47   // doing the same for text rendering.
  48   SkASSERT(shared_section);
  49   SkBaseDevice* device = VectorPlatformDeviceEmf::create(
  50       reinterpret_cast<HDC>(shared_section), width, height);
  51   return device;
  52 }
  53
  54 static void FillBitmapInfoHeader(int width, int height, BITMAPINFOHEADER* hdr) {
  55   hdr->biSize = sizeof(BITMAPINFOHEADER);
  56   hdr->biWidth = width;
  57   hdr->biHeight = -height;  // Minus means top-down bitmap.
  58   hdr->biPlanes = 1;
  59   hdr->biBitCount = 32;
  60   hdr->biCompression = BI_RGB;  // no compression
  61   hdr->biSizeImage = 0;
  62   hdr->biXPelsPerMeter = 1;
  63   hdr->biYPelsPerMeter = 1;
  64   hdr->biClrUsed = 0;
  65   hdr->biClrImportant = 0;
  66 }
  67
  68 SkBaseDevice* VectorPlatformDeviceEmf::create(HDC dc, int width, int height) {
  69   InitializeDC(dc);
  70
  71   // Link the SkBitmap to the current selected bitmap in the device context.
  72   SkBitmap bitmap;
  73   HGDIOBJ selected_bitmap = GetCurrentObject(dc, OBJ_BITMAP);
  74   bool succeeded = false;
  75   if (selected_bitmap != NULL) {
  76     BITMAP bitmap_data = {0};
  77     if (GetObject(selected_bitmap, sizeof(BITMAP), &bitmap_data) ==
  78         sizeof(BITMAP)) {
  79       // The context has a bitmap attached. Attach our SkBitmap to it.
  80       // Warning: If the bitmap gets unselected from the HDC,
  81       // VectorPlatformDeviceEmf has no way to detect this, so the HBITMAP
  82       // could be released while SkBitmap still has a reference to it. Be
  83       // cautious.
  84       if (width == bitmap_data.bmWidth && height == bitmap_data.bmHeight) {
  85         SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
  86         succeeded = bitmap.installPixels(info, bitmap_data.bmBits,
  87                                          bitmap_data.bmWidthBytes);
  88       }
  89     }
  90   }
  91
  92   if (!succeeded)
  93     bitmap.setInfo(SkImageInfo::MakeUnknown(width, height));
  94
  95   return new VectorPlatformDeviceEmf(dc, bitmap);
  96 }
  97
  98 VectorPlatformDeviceEmf::VectorPlatformDeviceEmf(HDC dc, const SkBitmap& bitmap)
  99     : SkBitmapDevice(bitmap),
 100       hdc_(dc),
 101       previous_brush_(NULL),
 102       previous_pen_(NULL) {
 103   transform_.reset();
 104   SetPlatformDevice(this, this);
 105 }
 106
 107 VectorPlatformDeviceEmf::~VectorPlatformDeviceEmf() {
 108   SkASSERT(previous_brush_ == NULL);
 109   SkASSERT(previous_pen_ == NULL);
 110 }
 111
 112 HDC VectorPlatformDeviceEmf::BeginPlatformPaint() {
 113   return hdc_;
 114 }
 115
 116 void VectorPlatformDeviceEmf::drawPaint(const SkDraw& draw,
 117                                         const SkPaint& paint) {
 118   // TODO(maruel):  Bypass the current transformation matrix.
 119   SkRect rect;
 120   rect.fLeft = 0;
 121   rect.fTop = 0;
 122   rect.fRight = SkIntToScalar(width() + 1);
 123   rect.fBottom = SkIntToScalar(height() + 1);
 124   drawRect(draw, rect, paint);
 125 }
 126
 127 void VectorPlatformDeviceEmf::drawPoints(const SkDraw& draw,
 128                                          SkCanvas::PointMode mode,
 129                                          size_t count,
 130                                          const SkPoint pts[],
 131                                          const SkPaint& paint) {
 132   if (!count)
 133     return;
 134
 135   if (mode == SkCanvas::kPoints_PointMode) {
 136     SkASSERT(false);
 137     return;
 138   }
 139
 140   SkPaint tmp_paint(paint);
 141   tmp_paint.setStyle(SkPaint::kStroke_Style);
 142
 143   // Draw a path instead.
 144   SkPath path;
 145   switch (mode) {
 146     case SkCanvas::kLines_PointMode:
 147       if (count % 2) {
 148         SkASSERT(false);
 149         return;
 150       }
 151       for (size_t i = 0; i < count / 2; ++i) {
 152         path.moveTo(pts[2 * i]);
 153         path.lineTo(pts[2 * i + 1]);
 154       }
 155       break;
 156     case SkCanvas::kPolygon_PointMode:
 157       path.moveTo(pts[0]);
 158       for (size_t i = 1; i < count; ++i) {
 159         path.lineTo(pts[i]);
 160       }
 161       break;
 162     default:
 163       SkASSERT(false);
 164       return;
 165   }
 166   // Draw the calculated path.
 167   drawPath(draw, path, tmp_paint);
 168 }
 169
 170 void VectorPlatformDeviceEmf::drawRect(const SkDraw& draw,
 171                                        const SkRect& rect,
 172                                        const SkPaint& paint) {
 173   CHECK_FOR_NODRAW_ANNOTATION(paint);
 174   if (paint.getPathEffect()) {
 175     // Draw a path instead.
 176     SkPath path_orginal;
 177     path_orginal.addRect(rect);
 178
 179     // Apply the path effect to the rect.
 180     SkPath path_modified;
 181     paint.getFillPath(path_orginal, &path_modified);
 182
 183     // Removes the path effect from the temporary SkPaint object.
 184     SkPaint paint_no_effet(paint);
 185     paint_no_effet.setPathEffect(NULL);
 186
 187     // Draw the calculated path.
 188     drawPath(draw, path_modified, paint_no_effet);
 189     return;
 190   }
 191
 192   if (!ApplyPaint(paint)) {
 193     return;
 194   }
 195   HDC dc = BeginPlatformPaint();
 196   if (!Rectangle(dc, SkScalarRoundToInt(rect.fLeft),
 197                  SkScalarRoundToInt(rect.fTop),
 198                  SkScalarRoundToInt(rect.fRight),
 199                  SkScalarRoundToInt(rect.fBottom))) {
 200     SkASSERT(false);
 201   }
 202   EndPlatformPaint();
 203   Cleanup();
 204 }
 205
 206 void VectorPlatformDeviceEmf::drawRRect(const SkDraw& draw, const SkRRect& rr,
 207                                         const SkPaint& paint) {
 208   SkPath path;
 209   path.addRRect(rr);
 210   this->drawPath(draw, path, paint, NULL, true);
 211 }
 212
 213 void VectorPlatformDeviceEmf::drawPath(const SkDraw& draw,
 214                                        const SkPath& path,
 215                                        const SkPaint& paint,
 216                                        const SkMatrix* prePathMatrix,
 217                                        bool pathIsMutable) {
 218   CHECK_FOR_NODRAW_ANNOTATION(paint);
 219   if (paint.getPathEffect()) {
 220     // Apply the path effect forehand.
 221     SkPath path_modified;
 222     paint.getFillPath(path, &path_modified);
 223
 224     // Removes the path effect from the temporary SkPaint object.
 225     SkPaint paint_no_effet(paint);
 226     paint_no_effet.setPathEffect(NULL);
 227
 228     // Draw the calculated path.
 229     drawPath(draw, path_modified, paint_no_effet);
 230     return;
 231   }
 232
 233   if (!ApplyPaint(paint)) {
 234     return;
 235   }
 236   HDC dc = BeginPlatformPaint();
 237   if (PlatformDevice::LoadPathToDC(dc, path)) {
 238     switch (paint.getStyle()) {
 239       case SkPaint::kFill_Style: {
 240         BOOL res = StrokeAndFillPath(dc);
 241         SkASSERT(res != 0);
 242         break;
 243       }
 244       case SkPaint::kStroke_Style: {
 245         BOOL res = StrokePath(dc);
 246         SkASSERT(res != 0);
 247         break;
 248       }
 249       case SkPaint::kStrokeAndFill_Style: {
 250         BOOL res = StrokeAndFillPath(dc);
 251         SkASSERT(res != 0);
 252         break;
 253       }
 254       default:
 255         SkASSERT(false);
 256         break;
 257     }
 258   }
 259   EndPlatformPaint();
 260   Cleanup();
 261 }
 262
 263 void VectorPlatformDeviceEmf::drawBitmapRect(const SkDraw& draw,
 264                                              const SkBitmap& bitmap,
 265                                              const SkRect* src,
 266                                              const SkRect& dst,
 267                                              const SkPaint& paint,
 268                                              SkCanvas::DrawBitmapRectFlags flags) {
 269     SkMatrix    matrix;
 270     SkRect      bitmapBounds, tmpSrc, tmpDst;
 271     SkBitmap    tmpBitmap;
 272
 273     bitmapBounds.isetWH(bitmap.width(), bitmap.height());
 274
 275     // Compute matrix from the two rectangles
 276     if (src) {
 277         tmpSrc = *src;
 278     } else {
 279         tmpSrc = bitmapBounds;
 280     }
 281     matrix.setRectToRect(tmpSrc, dst, SkMatrix::kFill_ScaleToFit);
 282
 283     const SkBitmap* bitmapPtr = &bitmap;
 284
 285     // clip the tmpSrc to the bounds of the bitmap, and recompute dstRect if
 286     // needed (if the src was clipped). No check needed if src==null.
 287     if (src) {
 288         if (!bitmapBounds.contains(*src)) {
 289             if (!tmpSrc.intersect(bitmapBounds)) {
 290                 return; // nothing to draw
 291             }
 292             // recompute dst, based on the smaller tmpSrc
 293             matrix.mapRect(&tmpDst, tmpSrc);
 294         }
 295
 296         // since we may need to clamp to the borders of the src rect within
 297         // the bitmap, we extract a subset.
 298         // TODO: make sure this is handled in drawrect and remove it from here.
 299         SkIRect srcIR;
 300         tmpSrc.roundOut(&srcIR);
 301         if (!bitmap.extractSubset(&tmpBitmap, srcIR)) {
 302             return;
 303         }
 304         bitmapPtr = &tmpBitmap;
 305
 306         // Since we did an extract, we need to adjust the matrix accordingly
 307         SkScalar dx = 0, dy = 0;
 308         if (srcIR.fLeft > 0) {
 309             dx = SkIntToScalar(srcIR.fLeft);
 310         }
 311         if (srcIR.fTop > 0) {
 312             dy = SkIntToScalar(srcIR.fTop);
 313         }
 314         if (dx || dy) {
 315             matrix.preTranslate(dx, dy);
 316         }
 317     }
 318     this->drawBitmap(draw, *bitmapPtr, matrix, paint);
 319 }
 320
 321 void VectorPlatformDeviceEmf::drawBitmap(const SkDraw& draw,
 322                                          const SkBitmap& bitmap,
 323                                          const SkMatrix& matrix,
 324                                          const SkPaint& paint) {
 325   // Load the temporary matrix. This is what will translate, rotate and resize
 326   // the bitmap.
 327   SkMatrix actual_transform(transform_);
 328   actual_transform.preConcat(matrix);
 329   LoadTransformToDC(hdc_, actual_transform);
 330
 331   InternalDrawBitmap(bitmap, 0, 0, paint);
 332
 333   // Restore the original matrix.
 334   LoadTransformToDC(hdc_, transform_);
 335 }
 336
 337 void VectorPlatformDeviceEmf::drawSprite(const SkDraw& draw,
 338                                          const SkBitmap& bitmap,
 339                                          int x, int y,
 340                                          const SkPaint& paint) {
 341   SkMatrix identity;
 342   identity.reset();
 343   LoadTransformToDC(hdc_, identity);
 344
 345   InternalDrawBitmap(bitmap, x, y, paint);
 346
 347   // Restore the original matrix.
 348   LoadTransformToDC(hdc_, transform_);
 349 }
 350
 351 /////////////////////////////////////////////////////////////////////////
 352
 353 static bool gdiCanHandleText(const SkPaint& paint) {
 354   return !paint.getShader() &&
 355          !paint.getPathEffect() &&
 356          (SkPaint::kFill_Style == paint.getStyle()) &&
 357          (255 == paint.getAlpha());
 358 }
 359
 360 class SkGDIFontSetup {
 361  public:
 362   SkGDIFontSetup() :
 363       fHDC(NULL),
 364       fNewFont(NULL),
 365       fSavedFont(NULL),
 366       fSavedTextColor(0),
 367       fUseGDI(false) {
 368     SkDEBUGCODE(fUseGDIHasBeenCalled = false;)
 369   }
 370   ~SkGDIFontSetup();
 371
 372   // can only be called once
 373   bool useGDI(HDC hdc, const SkPaint&);
 374
 375  private:
 376   HDC      fHDC;
 377   HFONT    fNewFont;
 378   HFONT    fSavedFont;
 379   COLORREF fSavedTextColor;
 380   bool     fUseGDI;
 381   SkDEBUGCODE(bool fUseGDIHasBeenCalled;)
 382 };
 383
 384 bool SkGDIFontSetup::useGDI(HDC hdc, const SkPaint& paint) {
 385   SkASSERT(!fUseGDIHasBeenCalled);
 386   SkDEBUGCODE(fUseGDIHasBeenCalled = true;)
 387
 388   fUseGDI = gdiCanHandleText(paint);
 389   if (fUseGDI) {
 390     fSavedTextColor = GetTextColor(hdc);
 391     SetTextColor(hdc, skia::SkColorToCOLORREF(paint.getColor()));
 392
 393     LOGFONT lf = {0};
 394     SkLOGFONTFromTypeface(paint.getTypeface(), &lf);
 395     lf.lfHeight = -SkScalarRoundToInt(paint.getTextSize());
 396     fNewFont = CreateFontIndirect(&lf);
 397     fSavedFont = (HFONT)::SelectObject(hdc, fNewFont);
 398     fHDC = hdc;
 399   }
 400   return fUseGDI;
 401 }
 402
 403 SkGDIFontSetup::~SkGDIFontSetup() {
 404   if (fUseGDI) {
 405     ::SelectObject(fHDC, fSavedFont);
 406     ::DeleteObject(fNewFont);
 407     SetTextColor(fHDC, fSavedTextColor);
 408   }
 409 }
 410
 411 static SkScalar getAscent(const SkPaint& paint) {
 412   SkPaint::FontMetrics fm;
 413   paint.getFontMetrics(&fm);
 414   return fm.fAscent;
 415 }
 416
 417 // return the options int for ExtTextOut. Only valid if the paint's text
 418 // encoding is not UTF8 (in which case ExtTextOut can't be used).
 419 static UINT getTextOutOptions(const SkPaint& paint) {
 420   if (SkPaint::kGlyphID_TextEncoding == paint.getTextEncoding()) {
 421     return ETO_GLYPH_INDEX;
 422   } else {
 423     SkASSERT(SkPaint::kUTF16_TextEncoding == paint.getTextEncoding());
 424     return 0;
 425   }
 426 }
 427
 428 static SkiaEnsureTypefaceCharactersAccessible
 429     g_skia_ensure_typeface_characters_accessible = NULL;
 430
 431 SK_API void SetSkiaEnsureTypefaceCharactersAccessible(
 432     SkiaEnsureTypefaceCharactersAccessible func) {
 433   // This function is supposed to be called once in process life time.
 434   SkASSERT(g_skia_ensure_typeface_characters_accessible == NULL);
 435   g_skia_ensure_typeface_characters_accessible = func;
 436 }
 437
 438 void EnsureTypefaceCharactersAccessible(
 439     const SkTypeface& typeface, const wchar_t* text, unsigned int text_length) {
 440   LOGFONT lf = {0};
 441   SkLOGFONTFromTypeface(&typeface, &lf);
 442   g_skia_ensure_typeface_characters_accessible(lf, text, text_length);
 443 }
 444
 445 bool EnsureExtTextOut(HDC hdc, int x, int y, UINT options, const RECT * lprect,
 446                       LPCWSTR text, unsigned int characters, const int * lpDx,
 447                       SkTypeface* const typeface) {
 448   bool success = ExtTextOut(hdc, x, y, options, lprect, text, characters, lpDx);
 449   if (!success) {
 450     if (typeface) {
 451       EnsureTypefaceCharactersAccessible(*typeface,
 452                                          text,
 453                                          characters);
 454       success = ExtTextOut(hdc, x, y, options, lprect, text, characters, lpDx);
 455       if (!success) {
 456         LOGFONT lf = {0};
 457         SkLOGFONTFromTypeface(typeface, &lf);
 458         VLOG(1) << "SkFontHost::EnsureTypefaceCharactersAccessible FAILED for "
 459                 << " FaceName = " << lf.lfFaceName
 460                 << " and characters: " << base::string16(text, characters);
 461       }
 462     } else {
 463       VLOG(1) << "ExtTextOut FAILED for default FaceName "
 464               << " and characters: " << base::string16(text, characters);
 465     }
 466   }
 467   return success;
 468 }
 469
 470 void VectorPlatformDeviceEmf::drawText(const SkDraw& draw,
 471                                        const void* text,
 472                                        size_t byteLength,
 473                                        SkScalar x,
 474                                        SkScalar y,
 475                                        const SkPaint& paint) {
 476   SkGDIFontSetup setup;
 477   bool useDrawPath = true;
 478
 479   if (SkPaint::kUTF8_TextEncoding != paint.getTextEncoding()
 480       && setup.useGDI(hdc_, paint)) {
 481     UINT options = getTextOutOptions(paint);
 482     UINT count = byteLength >> 1;
 483     useDrawPath = !EnsureExtTextOut(hdc_, SkScalarRoundToInt(x),
 484         SkScalarRoundToInt(y + getAscent(paint)), options, 0,
 485         reinterpret_cast<const wchar_t*>(text), count, NULL,
 486         paint.getTypeface());
 487   }
 488
 489   if (useDrawPath) {
 490     SkPath path;
 491     paint.getTextPath(text, byteLength, x, y, &path);
 492     drawPath(draw, path, paint);
 493   }
 494 }
 495
 496 static size_t size_utf8(const char* text) {
 497   return SkUTF8_CountUTF8Bytes(text);
 498 }
 499
 500 static size_t size_utf16(const char* text) {
 501   uint16_t c = *reinterpret_cast<const uint16_t*>(text);
 502   return SkUTF16_IsHighSurrogate(c) ? 4 : 2;
 503 }
 504
 505 static size_t size_glyphid(const char* text) {
 506   return 2;
 507 }
 508
 509 void VectorPlatformDeviceEmf::drawPosText(const SkDraw& draw,
 510                                           const void* text,
 511                                           size_t len,
 512                                           const SkScalar pos[],
 513                                           int scalarsPerPos,
 514                                           const SkPoint& offset,
 515                                           const SkPaint& paint) {
 516   SkGDIFontSetup setup;
 517   bool useDrawText = true;
 518
 519   if (scalarsPerPos == 2 && len >= 2 &&
 520       SkPaint::kUTF8_TextEncoding != paint.getTextEncoding() &&
 521       setup.useGDI(hdc_, paint)) {
 522     int startX = SkScalarRoundToInt(pos[0] + offset.x());
 523     int startY = SkScalarRoundToInt(pos[1] + offset.y() + getAscent(paint));
 524     const int count = len >> 1;
 525     SkAutoSTMalloc<64, INT> storage(count);
 526     INT* advances = storage.get();
 527     for (int i = 0; i < count - 1; ++i) {
 528       advances[i] = SkScalarRoundToInt(pos[2] - pos[0]);
 529       pos += 2;
 530     }
 531     advances[count - 1] = 0;
 532     useDrawText = !EnsureExtTextOut(hdc_, startX, startY,
 533         getTextOutOptions(paint), 0, reinterpret_cast<const wchar_t*>(text),
 534         count, advances, paint.getTypeface());
 535   }
 536
 537   if (useDrawText) {
 538     size_t (*bytesPerCodePoint)(const char*);
 539     switch (paint.getTextEncoding()) {
 540     case SkPaint::kUTF8_TextEncoding:
 541       bytesPerCodePoint = size_utf8;
 542       break;
 543     case SkPaint::kUTF16_TextEncoding:
 544       bytesPerCodePoint = size_utf16;
 545       break;
 546     default:
 547       SkASSERT(SkPaint::kGlyphID_TextEncoding == paint.getTextEncoding());
 548       bytesPerCodePoint = size_glyphid;
 549       break;
 550     }
 551
 552     const char* curr = reinterpret_cast<const char*>(text);
 553     const char* stop = curr + len;
 554     while (curr < stop) {
 555       SkScalar x = offset.x() + pos[0];
 556       SkScalar y = offset.y() + (2 == scalarsPerPos ? pos[1] : 0);
 557
 558       size_t bytes = bytesPerCodePoint(curr);
 559       drawText(draw, curr, bytes, x, y, paint);
 560       curr += bytes;
 561       pos += scalarsPerPos;
 562     }
 563   }
 564 }
 565
 566 void VectorPlatformDeviceEmf::drawTextOnPath(const SkDraw& draw,
 567                                              const void* text,
 568                                              size_t len,
 569                                              const SkPath& path,
 570                                              const SkMatrix* matrix,
 571                                              const SkPaint& paint) {
 572   // This function isn't used in the code. Verify this assumption.
 573   SkASSERT(false);
 574 }
 575
 576 void VectorPlatformDeviceEmf::drawVertices(const SkDraw& draw,
 577                                            SkCanvas::VertexMode vmode,
 578                                            int vertexCount,
 579                                            const SkPoint vertices[],
 580                                            const SkPoint texs[],
 581                                            const SkColor colors[],
 582                                            SkXfermode* xmode,
 583                                            const uint16_t indices[],
 584                                            int indexCount,
 585                                            const SkPaint& paint) {
 586   // This function isn't used in the code. Verify this assumption.
 587   SkASSERT(false);
 588 }
 589
 590 void VectorPlatformDeviceEmf::drawDevice(const SkDraw& draw,
 591                                          SkBaseDevice* device,
 592                                          int x,
 593                                          int y,
 594                                          const SkPaint& paint) {
 595   // TODO(maruel):  http://b/1183870 Playback the EMF buffer at printer's dpi if
 596   // it is a vectorial device.
 597   drawSprite(draw, device->accessBitmap(false), x, y, paint);
 598 }
 599
 600 bool VectorPlatformDeviceEmf::ApplyPaint(const SkPaint& paint) {
 601   // Note: The goal here is to transfert the SkPaint's state to the HDC's state.
 602   // This function does not execute the SkPaint drawing commands. These should
 603   // be executed in drawPaint().
 604
 605   SkPaint::Style style = paint.getStyle();
 606   if (!paint.getAlpha())
 607       style = (SkPaint::Style) SkPaint::kStyleCount;
 608
 609   switch (style) {
 610     case SkPaint::kFill_Style:
 611       if (!CreateBrush(true, paint) ||
 612           !CreatePen(false, paint))
 613         return false;
 614       break;
 615     case SkPaint::kStroke_Style:
 616       if (!CreateBrush(false, paint) ||
 617           !CreatePen(true, paint))
 618         return false;
 619       break;
 620     case SkPaint::kStrokeAndFill_Style:
 621       if (!CreateBrush(true, paint) ||
 622           !CreatePen(true, paint))
 623         return false;
 624       break;
 625     default:
 626       if (!CreateBrush(false, paint) ||
 627           !CreatePen(false, paint))
 628         return false;
 629       break;
 630   }
 631
 632   /*
 633   getFlags();
 634     isAntiAlias();
 635     isDither()
 636     isLinearText()
 637     isSubpixelText()
 638     isUnderlineText()
 639     isStrikeThruText()
 640     isFakeBoldText()
 641     isDevKernText()
 642     isFilterBitmap()
 643
 644   // Skia's text is not used. This should be fixed.
 645   getTextAlign()
 646   getTextScaleX()
 647   getTextSkewX()
 648   getTextEncoding()
 649   getFontMetrics()
 650   getFontSpacing()
 651   */
 652
 653   // BUG 1094907: Implement shaders. Shaders currently in use:
 654   //  SkShader::CreateBitmapShader
 655   //  SkGradientShader::CreateRadial
 656   //  SkGradientShader::CreateLinear
 657   // SkASSERT(!paint.getShader());
 658
 659   // http://b/1106647 Implement loopers and mask filter. Looper currently in
 660   // use:
 661   //   SkBlurDrawLooper is used for shadows.
 662   // SkASSERT(!paint.getLooper());
 663   // SkASSERT(!paint.getMaskFilter());
 664
 665   // http://b/1165900 Implement xfermode.
 666   // SkASSERT(!paint.getXfermode());
 667
 668   // The path effect should be processed before arriving here.
 669   SkASSERT(!paint.getPathEffect());
 670
 671   // This isn't used in the code. Verify this assumption.
 672   SkASSERT(!paint.getRasterizer());
 673   // Reuse code to load Win32 Fonts.
 674   return true;
 675 }
 676
 677 void VectorPlatformDeviceEmf::setMatrixClip(const SkMatrix& transform,
 678                                             const SkRegion& region,
 679                                             const SkClipStack&) {
 680   transform_ = transform;
 681   LoadTransformToDC(hdc_, transform_);
 682   clip_region_ = region;
 683   if (!clip_region_.isEmpty())
 684     LoadClipRegion();
 685 }
 686
 687 void VectorPlatformDeviceEmf::DrawToNativeContext(HDC dc, int x, int y,
 688                                                   const RECT* src_rect) {
 689   SkASSERT(false);
 690 }
 691
 692 void VectorPlatformDeviceEmf::LoadClipRegion() {
 693   SkMatrix t;
 694   t.reset();
 695   LoadClippingRegionToDC(hdc_, clip_region_, t);
 696 }
 697
 698 SkBaseDevice* VectorPlatformDeviceEmf::onCreateDevice(const SkImageInfo& info,
 699                                                       Usage /*usage*/) {
 700   SkASSERT(info.colorType() == kN32_SkColorType);
 701   return VectorPlatformDeviceEmf::CreateDevice(
 702       info.width(), info.height(), info.isOpaque(), NULL);
 703 }
 704
 705 bool VectorPlatformDeviceEmf::CreateBrush(bool use_brush, COLORREF color) {
 706   SkASSERT(previous_brush_ == NULL);
 707   // We can't use SetDCBrushColor() or DC_BRUSH when drawing to a EMF buffer.
 708   // SetDCBrushColor() calls are not recorded at all and DC_BRUSH will use
 709   // WHITE_BRUSH instead.
 710
 711   if (!use_brush) {
 712     // Set the transparency.
 713     if (0 == SetBkMode(hdc_, TRANSPARENT)) {
 714       SkASSERT(false);
 715       return false;
 716     }
 717
 718     // Select the NULL brush.
 719     previous_brush_ = SelectObject(GetStockObject(NULL_BRUSH));
 720     return previous_brush_ != NULL;
 721   }
 722
 723   // Set the opacity.
 724   if (0 == SetBkMode(hdc_, OPAQUE)) {
 725     SkASSERT(false);
 726     return false;
 727   }
 728
 729   // Create and select the brush.
 730   previous_brush_ = SelectObject(CreateSolidBrush(color));
 731   return previous_brush_ != NULL;
 732 }
 733
 734 bool VectorPlatformDeviceEmf::CreatePen(bool use_pen,
 735                                         COLORREF color,
 736                                         int stroke_width,
 737                                         float stroke_miter,
 738                                         DWORD pen_style) {
 739   SkASSERT(previous_pen_ == NULL);
 740   // We can't use SetDCPenColor() or DC_PEN when drawing to a EMF buffer.
 741   // SetDCPenColor() calls are not recorded at all and DC_PEN will use BLACK_PEN
 742   // instead.
 743
 744   // No pen case
 745   if (!use_pen) {
 746     previous_pen_ = SelectObject(GetStockObject(NULL_PEN));
 747     return previous_pen_ != NULL;
 748   }
 749
 750   // Use the stock pen if the stroke width is 0.
 751   if (stroke_width == 0) {
 752     // Create a pen with the right color.
 753     previous_pen_ = SelectObject(::CreatePen(PS_SOLID, 0, color));
 754     return previous_pen_ != NULL;
 755   }
 756
 757   // Load a custom pen.
 758   LOGBRUSH brush = {0};
 759   brush.lbStyle = BS_SOLID;
 760   brush.lbColor = color;
 761   brush.lbHatch = 0;
 762   HPEN pen = ExtCreatePen(pen_style, stroke_width, &brush, 0, NULL);
 763   SkASSERT(pen != NULL);
 764   previous_pen_ = SelectObject(pen);
 765   if (previous_pen_ == NULL)
 766     return false;
 767
 768   if (!SetMiterLimit(hdc_, stroke_miter, NULL)) {
 769     SkASSERT(false);
 770     return false;
 771   }
 772   return true;
 773 }
 774
 775 void VectorPlatformDeviceEmf::Cleanup() {
 776   if (previous_brush_) {
 777     HGDIOBJ result = SelectObject(previous_brush_);
 778     previous_brush_ = NULL;
 779     if (result) {
 780       BOOL res = DeleteObject(result);
 781       SkASSERT(res != 0);
 782     }
 783   }
 784   if (previous_pen_) {
 785     HGDIOBJ result = SelectObject(previous_pen_);
 786     previous_pen_ = NULL;
 787     if (result) {
 788       BOOL res = DeleteObject(result);
 789       SkASSERT(res != 0);
 790     }
 791   }
 792   // Remove any loaded path from the context.
 793   AbortPath(hdc_);
 794 }
 795
 796 HGDIOBJ VectorPlatformDeviceEmf::SelectObject(HGDIOBJ object) {
 797   HGDIOBJ result = ::SelectObject(hdc_, object);
 798   SkASSERT(result != HGDI_ERROR);
 799   if (result == HGDI_ERROR)
 800     return NULL;
 801   return result;
 802 }
 803
 804 bool VectorPlatformDeviceEmf::CreateBrush(bool use_brush,
 805                                           const SkPaint& paint) {
 806   // Make sure that for transparent color, no brush is used.
 807   if (paint.getAlpha() == 0) {
 808     use_brush = false;
 809   }
 810
 811   return CreateBrush(use_brush, SkColorToCOLORREF(paint.getColor()));
 812 }
 813
 814 bool VectorPlatformDeviceEmf::CreatePen(bool use_pen, const SkPaint& paint) {
 815   // Make sure that for transparent color, no pen is used.
 816   if (paint.getAlpha() == 0) {
 817     use_pen = false;
 818   }
 819
 820   DWORD pen_style = PS_GEOMETRIC | PS_SOLID;
 821   switch (paint.getStrokeJoin()) {
 822     case SkPaint::kMiter_Join:
 823       // Connects path segments with a sharp join.
 824       pen_style |= PS_JOIN_MITER;
 825       break;
 826     case SkPaint::kRound_Join:
 827       // Connects path segments with a round join.
 828       pen_style |= PS_JOIN_ROUND;
 829       break;
 830     case SkPaint::kBevel_Join:
 831       // Connects path segments with a flat bevel join.
 832       pen_style |= PS_JOIN_BEVEL;
 833       break;
 834     default:
 835       SkASSERT(false);
 836       break;
 837   }
 838   switch (paint.getStrokeCap()) {
 839     case SkPaint::kButt_Cap:
 840       // Begin/end contours with no extension.
 841       pen_style |= PS_ENDCAP_FLAT;
 842       break;
 843     case SkPaint::kRound_Cap:
 844       // Begin/end contours with a semi-circle extension.
 845       pen_style |= PS_ENDCAP_ROUND;
 846       break;
 847     case SkPaint::kSquare_Cap:
 848       // Begin/end contours with a half square extension.
 849       pen_style |= PS_ENDCAP_SQUARE;
 850       break;
 851     default:
 852       SkASSERT(false);
 853       break;
 854   }
 855
 856   return CreatePen(use_pen,
 857                    SkColorToCOLORREF(paint.getColor()),
 858                    SkScalarRoundToInt(paint.getStrokeWidth()),
 859                    paint.getStrokeMiter(),
 860                    pen_style);
 861 }
 862
 863 void VectorPlatformDeviceEmf::InternalDrawBitmap(const SkBitmap& bitmap,
 864                                                  int x, int y,
 865                                                  const SkPaint& paint) {
 866   unsigned char alpha = paint.getAlpha();
 867   if (alpha == 0)
 868     return;
 869
 870   bool is_translucent;
 871   if (alpha != 255) {
 872     // ApplyPaint expect an opaque color.
 873     SkPaint tmp_paint(paint);
 874     tmp_paint.setAlpha(255);
 875     if (!ApplyPaint(tmp_paint))
 876       return;
 877     is_translucent = true;
 878   } else {
 879     if (!ApplyPaint(paint))
 880       return;
 881     is_translucent = false;
 882   }
 883   int src_size_x = bitmap.width();
 884   int src_size_y = bitmap.height();
 885   if (!src_size_x || !src_size_y)
 886     return;
 887
 888   // Create a BMP v4 header that we can serialize. We use the shared "V3"
 889   // fillter to fill the stardard items, then add in the "V4" stuff we want.
 890   BITMAPV4HEADER bitmap_header = {0};
 891   FillBitmapInfoHeader(src_size_x, src_size_y,
 892                        reinterpret_cast<BITMAPINFOHEADER*>(&bitmap_header));
 893   bitmap_header.bV4Size = sizeof(BITMAPV4HEADER);
 894   bitmap_header.bV4RedMask   = 0x00ff0000;
 895   bitmap_header.bV4GreenMask = 0x0000ff00;
 896   bitmap_header.bV4BlueMask  = 0x000000ff;
 897   bitmap_header.bV4AlphaMask = 0xff000000;
 898
 899   SkAutoLockPixels lock(bitmap);
 900   SkASSERT(bitmap.colorType() == kN32_SkColorType);
 901   const uint32_t* pixels = static_cast<const uint32_t*>(bitmap.getPixels());
 902   if (pixels == NULL) {
 903     SkASSERT(false);
 904     return;
 905   }
 906
 907   if (!is_translucent) {
 908     int row_length = bitmap.rowBytesAsPixels();
 909     // There is no quick way to determine if an image is opaque.
 910     for (int y2 = 0; y2 < src_size_y; ++y2) {
 911       for (int x2 = 0; x2 < src_size_x; ++x2) {
 912         if (SkColorGetA(pixels[(y2 * row_length) + x2]) != 255) {
 913           is_translucent = true;
 914           y2 = src_size_y;
 915           break;
 916         }
 917       }
 918     }
 919   }
 920
 921   HDC dc = BeginPlatformPaint();
 922   BITMAPINFOHEADER hdr = {0};
 923   FillBitmapInfoHeader(src_size_x, src_size_y, &hdr);
 924   if (is_translucent) {
 925     // The image must be loaded as a bitmap inside a device context.
 926     HDC bitmap_dc = ::CreateCompatibleDC(dc);
 927     void* bits = NULL;
 928     HBITMAP hbitmap = ::CreateDIBSection(
 929         bitmap_dc, reinterpret_cast<const BITMAPINFO*>(&hdr),
 930         DIB_RGB_COLORS, &bits, NULL, 0);
 931
 932     // static cast to a char so we can do byte ptr arithmatic to
 933     // get the offset.
 934     unsigned char* dest_buffer = static_cast<unsigned char *>(bits);
 935
 936     // We will copy row by row to avoid having to worry about
 937     // the row strides being different.
 938     const int dest_row_size = hdr.biBitCount / 8 * hdr.biWidth;
 939     for (int row = 0; row < bitmap.height(); ++row) {
 940       int dest_offset = row * dest_row_size;
 941       // pixels_offset in terms of pixel count.
 942       int src_offset = row * bitmap.rowBytesAsPixels();
 943       memcpy(dest_buffer + dest_offset, pixels + src_offset, dest_row_size);
 944     }
 945     SkASSERT(hbitmap);
 946     HGDIOBJ old_bitmap = ::SelectObject(bitmap_dc, hbitmap);
 947
 948     // After some analysis of IE7's behavior, this is the thing to do. I was
 949     // sure IE7 was doing so kind of bitmasking due to the way translucent image
 950     // where renderered but after some windbg tracing, it is being done by the
 951     // printer driver after all (mostly HP printers). IE7 always use AlphaBlend
 952     // for bitmasked images. The trick seems to switch the stretching mode in
 953     // what the driver expects.
 954     DWORD previous_mode = GetStretchBltMode(dc);
 955     BOOL result = SetStretchBltMode(dc, COLORONCOLOR);
 956     SkASSERT(result);
 957     // Note that this function expect premultiplied colors (!)
 958     BLENDFUNCTION blend_function = {AC_SRC_OVER, 0, alpha, AC_SRC_ALPHA};
 959     result = GdiAlphaBlend(dc,
 960                            x, y,  // Destination origin.
 961                            src_size_x, src_size_y,  // Destination size.
 962                            bitmap_dc,
 963                            0, 0,  // Source origin.
 964                            src_size_x, src_size_y,  // Source size.
 965                            blend_function);
 966     SkASSERT(result);
 967     result = SetStretchBltMode(dc, previous_mode);
 968     SkASSERT(result);
 969
 970     ::SelectObject(bitmap_dc, static_cast<HBITMAP>(old_bitmap));
 971     DeleteObject(hbitmap);
 972     DeleteDC(bitmap_dc);
 973   } else {
 974     int nCopied = StretchDIBits(dc,
 975                                 x, y,  // Destination origin.
 976                                 src_size_x, src_size_y,
 977                                 0, 0,  // Source origin.
 978                                 src_size_x, src_size_y,  // Source size.
 979                                 pixels,
 980                                 reinterpret_cast<const BITMAPINFO*>(&hdr),
 981                                 DIB_RGB_COLORS,
 982                                 SRCCOPY);
 983   }
 984   EndPlatformPaint();
 985   Cleanup();
 986 }
 987
 988 }  // namespace skia