src/third_party/skia/src/device/xps/SkXPSDevice.cpp

   1 /*
   2  * Copyright 2011 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #ifndef UNICODE
   9 #define UNICODE
  10 #endif
  11 #ifndef _UNICODE
  12 #define _UNICODE
  13 #endif
  14 #include "SkTypes.h"
  15 #include <ObjBase.h>
  16 #include <XpsObjectModel.h>
  17 #include <T2EmbApi.h>
  18 #include <FontSub.h>
  19
  20 #include "SkColor.h"
  21 #include "SkConstexprMath.h"
  22 #include "SkData.h"
  23 #include "SkDraw.h"
  24 #include "SkDrawProcs.h"
  25 #include "SkEndian.h"
  26 #include "SkFontHost.h"
  27 #include "SkGlyphCache.h"
  28 #include "SkHRESULT.h"
  29 #include "SkImageEncoder.h"
  30 #include "SkIStream.h"
  31 #include "SkMaskFilter.h"
  32 #include "SkPaint.h"
  33 #include "SkPoint.h"
  34 #include "SkRasterizer.h"
  35 #include "SkSFNTHeader.h"
  36 #include "SkShader.h"
  37 #include "SkSize.h"
  38 #include "SkStream.h"
  39 #include "SkTDArray.h"
  40 #include "SkTLazy.h"
  41 #include "SkTScopedComPtr.h"
  42 #include "SkTTCFHeader.h"
  43 #include "SkTypefacePriv.h"
  44 #include "SkUtils.h"
  45 #include "SkXPSDevice.h"
  46
  47 //Windows defines a FLOAT type,
  48 //make it clear when converting a scalar that this is what is wanted.
  49 #define SkScalarToFLOAT(n) SkScalarToFloat(n)
  50
  51 //Dummy representation of a GUID from create_id.
  52 #define L_GUID_ID L"XXXXXXXXsXXXXsXXXXsXXXXsXXXXXXXXXXXX"
  53 //Length of GUID representation from create_id, including NULL terminator.
  54 #define GUID_ID_LEN SK_ARRAY_COUNT(L_GUID_ID)
  55
  56 /**
  57    Formats a GUID and places it into buffer.
  58    buffer should have space for at least GUID_ID_LEN wide characters.
  59    The string will always be wchar null terminated.
  60    XXXXXXXXsXXXXsXXXXsXXXXsXXXXXXXXXXXX0
  61    @return -1 if there was an error, > 0 if success.
  62  */
  63 static int format_guid(const GUID& guid,
  64                        wchar_t* buffer, size_t bufferSize,
  65                        wchar_t sep = '-') {
  66     SkASSERT(bufferSize >= GUID_ID_LEN);
  67     return swprintf_s(buffer,
  68                       bufferSize,
  69                       L"%08lX%c%04X%c%04X%c%02X%02X%c%02X%02X%02X%02X%02X%02X",
  70                       guid.Data1,
  71                       sep,
  72                       guid.Data2,
  73                       sep,
  74                       guid.Data3,
  75                       sep,
  76                       guid.Data4[0],
  77                       guid.Data4[1],
  78                       sep,
  79                       guid.Data4[2],
  80                       guid.Data4[3],
  81                       guid.Data4[4],
  82                       guid.Data4[5],
  83                       guid.Data4[6],
  84                       guid.Data4[7]);
  85 }
  86
  87 /**
  88    Creates a GUID based id and places it into buffer.
  89    buffer should have space for at least GUID_ID_LEN wide characters.
  90    The string will always be wchar null terminated.
  91    XXXXXXXXsXXXXsXXXXsXXXXsXXXXXXXXXXXX0
  92    The string may begin with a digit,
  93    and so may not be suitable as a bare resource key.
  94  */
  95 static HRESULT create_id(wchar_t* buffer, size_t bufferSize,
  96                          wchar_t sep = '-') {
  97     GUID guid = {};
  98     HRM(CoCreateGuid(&guid), "Could not create GUID for id.");
  99
 100     if (format_guid(guid, buffer, bufferSize, sep) == -1) {
 101         HRM(E_UNEXPECTED, "Could not format GUID into id.");
 102     }
 103
 104     return S_OK;
 105 }
 106
 107 static SkBitmap make_fake_bitmap(int width, int height) {
 108     SkBitmap bitmap;
 109     bitmap.setConfig(SkBitmap::kNo_Config, width, height);
 110     return bitmap;
 111 }
 112
 113 SkXPSDevice::SkXPSDevice()
 114     : SkBitmapDevice(make_fake_bitmap(10000, 10000))
 115     , fCurrentPage(0) {
 116 }
 117
 118 SkXPSDevice::~SkXPSDevice() {
 119 }
 120
 121 SkXPSDevice::TypefaceUse::TypefaceUse()
 122     : typefaceId(0xffffffff)
 123     , fontData(NULL)
 124     , xpsFont(NULL)
 125     , glyphsUsed(NULL) {
 126 }
 127
 128 SkXPSDevice::TypefaceUse::~TypefaceUse() {
 129     //xpsFont owns fontData ref
 130     this->xpsFont->Release();
 131     delete this->glyphsUsed;
 132 }
 133
 134 bool SkXPSDevice::beginPortfolio(SkWStream* outputStream) {
 135     if (!this->fAutoCo.succeeded()) return false;
 136
 137     //Create XPS Factory.
 138     HRBM(CoCreateInstance(
 139              CLSID_XpsOMObjectFactory,
 140              NULL,
 141              CLSCTX_INPROC_SERVER,
 142              IID_PPV_ARGS(&this->fXpsFactory)),
 143          "Could not create XPS factory.");
 144
 145     HRBM(SkWIStream::CreateFromSkWStream(outputStream, &this->fOutputStream),
 146          "Could not convert SkStream to IStream.");
 147
 148     return true;
 149 }
 150
 151 bool SkXPSDevice::beginSheet(
 152         const SkVector& unitsPerMeter,
 153         const SkVector& pixelsPerMeter,
 154         const SkSize& trimSize,
 155         const SkRect* mediaBox,
 156         const SkRect* bleedBox,
 157         const SkRect* artBox,
 158         const SkRect* cropBox) {
 159     ++this->fCurrentPage;
 160
 161     //For simplicity, just write everything out in geometry units,
 162     //then have a base canvas do the scale to physical units.
 163     this->fCurrentCanvasSize = trimSize;
 164     this->fCurrentUnitsPerMeter = unitsPerMeter;
 165     this->fCurrentPixelsPerMeter = pixelsPerMeter;
 166
 167     this->fCurrentXpsCanvas.reset();
 168     HRBM(this->fXpsFactory->CreateCanvas(&this->fCurrentXpsCanvas),
 169          "Could not create base canvas.");
 170
 171     return true;
 172 }
 173
 174 HRESULT SkXPSDevice::createXpsThumbnail(IXpsOMPage* page,
 175                                         const unsigned int pageNum,
 176                                         IXpsOMImageResource** image) {
 177     SkTScopedComPtr<IXpsOMThumbnailGenerator> thumbnailGenerator;
 178     HRM(CoCreateInstance(
 179             CLSID_XpsOMThumbnailGenerator,
 180             NULL,
 181             CLSCTX_INPROC_SERVER,
 182             IID_PPV_ARGS(&thumbnailGenerator)),
 183         "Could not create thumbnail generator.");
 184
 185     SkTScopedComPtr<IOpcPartUri> partUri;
 186     static const size_t size = SkTUMax<
 187         SK_ARRAY_COUNT(L"/Documents/1/Metadata/.png") + SK_DIGITS_IN(pageNum),
 188         SK_ARRAY_COUNT(L"/Metadata/" L_GUID_ID L".png")
 189     >::value;
 190     wchar_t buffer[size];
 191     if (pageNum > 0) {
 192         swprintf_s(buffer, size, L"/Documents/1/Metadata/%u.png", pageNum);
 193     } else {
 194         wchar_t id[GUID_ID_LEN];
 195         HR(create_id(id, GUID_ID_LEN));
 196         swprintf_s(buffer, size, L"/Metadata/%s.png", id);
 197     }
 198     HRM(this->fXpsFactory->CreatePartUri(buffer, &partUri),
 199         "Could not create thumbnail part uri.");
 200
 201     HRM(thumbnailGenerator->GenerateThumbnail(page,
 202                                               XPS_IMAGE_TYPE_PNG,
 203                                               XPS_THUMBNAIL_SIZE_LARGE,
 204                                               partUri.get(),
 205                                               image),
 206         "Could not generate thumbnail.");
 207
 208     return S_OK;
 209 }
 210
 211 HRESULT SkXPSDevice::createXpsPage(const XPS_SIZE& pageSize,
 212                                    IXpsOMPage** page) {
 213     static const size_t size = SK_ARRAY_COUNT(L"/Documents/1/Pages/.fpage")
 214                              + SK_DIGITS_IN(fCurrentPage);
 215     wchar_t buffer[size];
 216     swprintf_s(buffer, size, L"/Documents/1/Pages/%u.fpage",
 217                              this->fCurrentPage);
 218     SkTScopedComPtr<IOpcPartUri> partUri;
 219     HRM(this->fXpsFactory->CreatePartUri(buffer, &partUri),
 220         "Could not create page part uri.");
 221
 222     //If the language is unknown, use "und" (XPS Spec 2.3.5.1).
 223     HRM(this->fXpsFactory->CreatePage(&pageSize,
 224                                       L"und",
 225                                       partUri.get(),
 226                                       page),
 227         "Could not create page.");
 228
 229     return S_OK;
 230 }
 231
 232 HRESULT SkXPSDevice::initXpsDocumentWriter(IXpsOMImageResource* image) {
 233     //Create package writer.
 234     {
 235         SkTScopedComPtr<IOpcPartUri> partUri;
 236         HRM(this->fXpsFactory->CreatePartUri(L"/FixedDocumentSequence.fdseq",
 237                                              &partUri),
 238             "Could not create document sequence part uri.");
 239         HRM(this->fXpsFactory->CreatePackageWriterOnStream(
 240                 this->fOutputStream.get(),
 241                 TRUE,
 242                 XPS_INTERLEAVING_OFF, //XPS_INTERLEAVING_ON,
 243                 partUri.get(),
 244                 NULL,
 245                 image,
 246                 NULL,
 247                 NULL,
 248                 &this->fPackageWriter),
 249             "Could not create package writer.");
 250     }
 251
 252     //Begin the lone document.
 253     {
 254         SkTScopedComPtr<IOpcPartUri> partUri;
 255         HRM(this->fXpsFactory->CreatePartUri(
 256                 L"/Documents/1/FixedDocument.fdoc",
 257                 &partUri),
 258             "Could not create fixed document part uri.");
 259         HRM(this->fPackageWriter->StartNewDocument(partUri.get(),
 260                                                    NULL,
 261                                                    NULL,
 262                                                    NULL,
 263                                                    NULL),
 264             "Could not start document.");
 265     }
 266
 267     return S_OK;
 268 }
 269
 270 bool SkXPSDevice::endSheet() {
 271     //XPS is fixed at 96dpi (XPS Spec 11.1).
 272     static const float xpsDPI = 96.0f;
 273     static const float inchesPerMeter = 10000.0f / 254.0f;
 274     static const float targetUnitsPerMeter = xpsDPI * inchesPerMeter;
 275     const float scaleX = targetUnitsPerMeter
 276                        / SkScalarToFLOAT(this->fCurrentUnitsPerMeter.fX);
 277     const float scaleY = targetUnitsPerMeter
 278                        / SkScalarToFLOAT(this->fCurrentUnitsPerMeter.fY);
 279
 280     //Create the scale canvas.
 281     SkTScopedComPtr<IXpsOMCanvas> scaleCanvas;
 282     HRBM(this->fXpsFactory->CreateCanvas(&scaleCanvas),
 283          "Could not create scale canvas.");
 284     SkTScopedComPtr<IXpsOMVisualCollection> scaleCanvasVisuals;
 285     HRBM(scaleCanvas->GetVisuals(&scaleCanvasVisuals),
 286          "Could not get scale canvas visuals.");
 287
 288     SkTScopedComPtr<IXpsOMMatrixTransform> geomToPhys;
 289     XPS_MATRIX rawGeomToPhys = { scaleX, 0, 0, scaleY, 0, 0, };
 290     HRBM(this->fXpsFactory->CreateMatrixTransform(&rawGeomToPhys, &geomToPhys),
 291          "Could not create geometry to physical transform.");
 292     HRBM(scaleCanvas->SetTransformLocal(geomToPhys.get()),
 293          "Could not set transform on scale canvas.");
 294
 295     //Add the content canvas to the scale canvas.
 296     HRBM(scaleCanvasVisuals->Append(this->fCurrentXpsCanvas.get()),
 297          "Could not add base canvas to scale canvas.");
 298
 299     //Create the page.
 300     XPS_SIZE pageSize = {
 301         SkScalarToFLOAT(this->fCurrentCanvasSize.width()) * scaleX,
 302         SkScalarToFLOAT(this->fCurrentCanvasSize.height()) * scaleY,
 303     };
 304     SkTScopedComPtr<IXpsOMPage> page;
 305     HRB(this->createXpsPage(pageSize, &page));
 306
 307     SkTScopedComPtr<IXpsOMVisualCollection> pageVisuals;
 308     HRBM(page->GetVisuals(&pageVisuals), "Could not get page visuals.");
 309
 310     //Add the scale canvas to the page.
 311     HRBM(pageVisuals->Append(scaleCanvas.get()),
 312          "Could not add scale canvas to page.");
 313
 314     //Create the package writer if it hasn't been created yet.
 315     if (NULL == this->fPackageWriter.get()) {
 316         SkTScopedComPtr<IXpsOMImageResource> image;
 317         //Ignore return, thumbnail is completely optional.
 318         this->createXpsThumbnail(page.get(), 0, &image);
 319
 320         HRB(this->initXpsDocumentWriter(image.get()));
 321     }
 322
 323     HRBM(this->fPackageWriter->AddPage(page.get(),
 324                                        &pageSize,
 325                                        NULL,
 326                                        NULL,
 327                                        NULL,
 328                                        NULL),
 329          "Could not write the page.");
 330     this->fCurrentXpsCanvas.reset();
 331
 332     return true;
 333 }
 334
 335 static HRESULT subset_typeface(SkXPSDevice::TypefaceUse* current) {
 336     //CreateFontPackage wants unsigned short.
 337     //Microsoft, Y U NO stdint.h?
 338     SkTDArray<unsigned short> keepList;
 339     current->glyphsUsed->exportTo(&keepList);
 340
 341     int ttcCount = (current->ttcIndex + 1);
 342
 343     //The following are declared with the types required by CreateFontPackage.
 344     unsigned char *fontPackageBufferRaw = NULL;
 345     unsigned long fontPackageBufferSize;
 346     unsigned long bytesWritten;
 347     unsigned long result = CreateFontPackage(
 348         (unsigned char *) current->fontData->getMemoryBase(),
 349         (unsigned long) current->fontData->getLength(),
 350         &fontPackageBufferRaw,
 351         &fontPackageBufferSize,
 352         &bytesWritten,
 353         TTFCFP_FLAGS_SUBSET | TTFCFP_FLAGS_GLYPHLIST | (ttcCount > 0 ? TTFCFP_FLAGS_TTC : 0),
 354         current->ttcIndex,
 355         TTFCFP_SUBSET,
 356         0,
 357         0,
 358         0,
 359         keepList.begin(),
 360         keepList.count(),
 361         sk_malloc_throw,
 362         sk_realloc_throw,
 363         sk_free,
 364         NULL);
 365     SkAutoTMalloc<unsigned char> fontPackageBuffer(fontPackageBufferRaw);
 366     if (result != NO_ERROR) {
 367         SkDEBUGF(("CreateFontPackage Error %lu", result));
 368         return E_UNEXPECTED;
 369     }
 370
 371     // If it was originally a ttc, keep it a ttc.
 372     // CreateFontPackage over-allocates, realloc usually decreases the size substantially.
 373     size_t extra;
 374     if (ttcCount > 0) {
 375         // Create space for a ttc header.
 376         extra = sizeof(SkTTCFHeader) + (ttcCount * sizeof(SK_OT_ULONG));
 377         fontPackageBuffer.realloc(bytesWritten + extra);
 378         //overlap is certain, use memmove
 379         memmove(fontPackageBuffer.get() + extra, fontPackageBuffer.get(), bytesWritten);
 380
 381         // Write the ttc header.
 382         SkTTCFHeader* ttcfHeader = reinterpret_cast<SkTTCFHeader*>(fontPackageBuffer.get());
 383         ttcfHeader->ttcTag = SkTTCFHeader::TAG;
 384         ttcfHeader->version = SkTTCFHeader::version_1;
 385         ttcfHeader->numOffsets = SkEndian_SwapBE32(ttcCount);
 386         SK_OT_ULONG* offsetPtr = SkTAfter<SK_OT_ULONG>(ttcfHeader);
 387         for (int i = 0; i < ttcCount; ++i, ++offsetPtr) {
 388             *offsetPtr = SkEndian_SwapBE32(extra);
 389         }
 390
 391         // Fix up offsets in sfnt table entries.
 392         SkSFNTHeader* sfntHeader = SkTAddOffset<SkSFNTHeader>(fontPackageBuffer.get(), extra);
 393         int numTables = SkEndian_SwapBE16(sfntHeader->numTables);
 394         SkSFNTHeader::TableDirectoryEntry* tableDirectory =
 395             SkTAfter<SkSFNTHeader::TableDirectoryEntry>(sfntHeader);
 396         for (int i = 0; i < numTables; ++i, ++tableDirectory) {
 397             tableDirectory->offset = SkEndian_SwapBE32(
 398                 SkEndian_SwapBE32(tableDirectory->offset) + extra);
 399         }
 400     } else {
 401         extra = 0;
 402         fontPackageBuffer.realloc(bytesWritten);
 403     }
 404
 405     SkAutoTUnref<SkMemoryStream> newStream(new SkMemoryStream());
 406     newStream->setMemoryOwned(fontPackageBuffer.detach(), bytesWritten + extra);
 407
 408     SkTScopedComPtr<IStream> newIStream;
 409     SkIStream::CreateFromSkStream(newStream.detach(), true, &newIStream);
 410
 411     XPS_FONT_EMBEDDING embedding;
 412     HRM(current->xpsFont->GetEmbeddingOption(&embedding),
 413         "Could not get embedding option from font.");
 414
 415     SkTScopedComPtr<IOpcPartUri> partUri;
 416     HRM(current->xpsFont->GetPartName(&partUri),
 417         "Could not get part uri from font.");
 418
 419     HRM(current->xpsFont->SetContent(
 420             newIStream.get(),
 421             embedding,
 422             partUri.get()),
 423         "Could not set new stream for subsetted font.");
 424
 425     return S_OK;
 426 }
 427
 428 bool SkXPSDevice::endPortfolio() {
 429     //Subset fonts
 430     if (!this->fTypefaces.empty()) {
 431         SkXPSDevice::TypefaceUse* current = &this->fTypefaces.front();
 432         const TypefaceUse* last = &this->fTypefaces.back();
 433         for (; current <= last; ++current) {
 434             //Ignore return for now, if it didn't subset, let it be.
 435             subset_typeface(current);
 436         }
 437     }
 438
 439     HRBM(this->fPackageWriter->Close(), "Could not close writer.");
 440
 441     return true;
 442 }
 443
 444 static XPS_COLOR xps_color(const SkColor skColor) {
 445     //XPS uses non-pre-multiplied alpha (XPS Spec 11.4).
 446     XPS_COLOR xpsColor;
 447     xpsColor.colorType = XPS_COLOR_TYPE_SRGB;
 448     xpsColor.value.sRGB.alpha = SkColorGetA(skColor);
 449     xpsColor.value.sRGB.red = SkColorGetR(skColor);
 450     xpsColor.value.sRGB.green = SkColorGetG(skColor);
 451     xpsColor.value.sRGB.blue = SkColorGetB(skColor);
 452
 453     return xpsColor;
 454 }
 455
 456 static XPS_POINT xps_point(const SkPoint& point) {
 457     XPS_POINT xpsPoint = {
 458         SkScalarToFLOAT(point.fX),
 459         SkScalarToFLOAT(point.fY),
 460     };
 461     return xpsPoint;
 462 }
 463
 464 static XPS_POINT xps_point(const SkPoint& point, const SkMatrix& matrix) {
 465     SkPoint skTransformedPoint;
 466     matrix.mapXY(point.fX, point.fY, &skTransformedPoint);
 467     return xps_point(skTransformedPoint);
 468 }
 469
 470 static XPS_SPREAD_METHOD xps_spread_method(SkShader::TileMode tileMode) {
 471     switch (tileMode) {
 472     case SkShader::kClamp_TileMode:
 473         return XPS_SPREAD_METHOD_PAD;
 474     case SkShader::kRepeat_TileMode:
 475         return XPS_SPREAD_METHOD_REPEAT;
 476     case SkShader::kMirror_TileMode:
 477         return XPS_SPREAD_METHOD_REFLECT;
 478     default:
 479         SkDEBUGFAIL("Unknown tile mode.");
 480     }
 481     return XPS_SPREAD_METHOD_PAD;
 482 }
 483
 484 static void transform_offsets(SkScalar* stopOffsets, const int numOffsets,
 485                               const SkPoint& start, const SkPoint& end,
 486                               const SkMatrix& transform) {
 487     SkPoint startTransformed;
 488     transform.mapXY(start.fX, start.fY, &startTransformed);
 489     SkPoint endTransformed;
 490     transform.mapXY(end.fX, end.fY, &endTransformed);
 491
 492     //Manhattan distance between transformed start and end.
 493     SkScalar startToEnd = (endTransformed.fX - startTransformed.fX)
 494                         + (endTransformed.fY - startTransformed.fY);
 495     if (SkScalarNearlyZero(startToEnd)) {
 496         for (int i = 0; i < numOffsets; ++i) {
 497             stopOffsets[i] = 0;
 498         }
 499         return;
 500     }
 501
 502     for (int i = 0; i < numOffsets; ++i) {
 503         SkPoint stop;
 504         stop.fX = SkScalarMul(end.fX - start.fX, stopOffsets[i]);
 505         stop.fY = SkScalarMul(end.fY - start.fY, stopOffsets[i]);
 506
 507         SkPoint stopTransformed;
 508         transform.mapXY(stop.fX, stop.fY, &stopTransformed);
 509
 510         //Manhattan distance between transformed start and stop.
 511         SkScalar startToStop = (stopTransformed.fX - startTransformed.fX)
 512                              + (stopTransformed.fY - startTransformed.fY);
 513         //Percentage along transformed line.
 514         stopOffsets[i] = SkScalarDiv(startToStop, startToEnd);
 515     }
 516 }
 517
 518 HRESULT SkXPSDevice::createXpsTransform(const SkMatrix& matrix,
 519                                         IXpsOMMatrixTransform** xpsTransform) {
 520     SkScalar affine[6];
 521     if (!matrix.asAffine(affine)) {
 522         *xpsTransform = NULL;
 523         return S_FALSE;
 524     }
 525     XPS_MATRIX rawXpsMatrix = {
 526         SkScalarToFLOAT(affine[SkMatrix::kAScaleX]),
 527         SkScalarToFLOAT(affine[SkMatrix::kASkewY]),
 528         SkScalarToFLOAT(affine[SkMatrix::kASkewX]),
 529         SkScalarToFLOAT(affine[SkMatrix::kAScaleY]),
 530         SkScalarToFLOAT(affine[SkMatrix::kATransX]),
 531         SkScalarToFLOAT(affine[SkMatrix::kATransY]),
 532     };
 533     HRM(this->fXpsFactory->CreateMatrixTransform(&rawXpsMatrix, xpsTransform),
 534         "Could not create transform.");
 535
 536     return S_OK;
 537 }
 538
 539 HRESULT SkXPSDevice::createPath(IXpsOMGeometryFigure* figure,
 540                                 IXpsOMVisualCollection* visuals,
 541                                 IXpsOMPath** path) {
 542     SkTScopedComPtr<IXpsOMGeometry> geometry;
 543     HRM(this->fXpsFactory->CreateGeometry(&geometry),
 544         "Could not create geometry.");
 545
 546     SkTScopedComPtr<IXpsOMGeometryFigureCollection> figureCollection;
 547     HRM(geometry->GetFigures(&figureCollection), "Could not get figures.");
 548     HRM(figureCollection->Append(figure), "Could not add figure.");
 549
 550     HRM(this->fXpsFactory->CreatePath(path), "Could not create path.");
 551     HRM((*path)->SetGeometryLocal(geometry.get()), "Could not set geometry");
 552
 553     HRM(visuals->Append(*path), "Could not add path to visuals.");
 554     return S_OK;
 555 }
 556
 557 HRESULT SkXPSDevice::createXpsSolidColorBrush(const SkColor skColor,
 558                                               const SkAlpha alpha,
 559                                               IXpsOMBrush** xpsBrush) {
 560     XPS_COLOR xpsColor = xps_color(skColor);
 561     SkTScopedComPtr<IXpsOMSolidColorBrush> solidBrush;
 562     HRM(this->fXpsFactory->CreateSolidColorBrush(&xpsColor, NULL, &solidBrush),
 563         "Could not create solid color brush.");
 564     HRM(solidBrush->SetOpacity(alpha / 255.0f), "Could not set opacity.");
 565     HRM(solidBrush->QueryInterface<IXpsOMBrush>(xpsBrush), "QI Fail.");
 566     return S_OK;
 567 }
 568
 569 HRESULT SkXPSDevice::sideOfClamp(const SkRect& areaToFill,
 570                                  const XPS_RECT& imageViewBox,
 571                                  IXpsOMImageResource* image,
 572                                  IXpsOMVisualCollection* visuals) {
 573     SkTScopedComPtr<IXpsOMGeometryFigure> areaToFillFigure;
 574     HR(this->createXpsRect(areaToFill, FALSE, TRUE, &areaToFillFigure));
 575
 576     SkTScopedComPtr<IXpsOMPath> areaToFillPath;
 577     HR(this->createPath(areaToFillFigure.get(), visuals, &areaToFillPath));
 578
 579     SkTScopedComPtr<IXpsOMImageBrush> areaToFillBrush;
 580     HRM(this->fXpsFactory->CreateImageBrush(image,
 581                                             &imageViewBox,
 582                                             &imageViewBox,
 583                                             &areaToFillBrush),
 584         "Could not create brush for side of clamp.");
 585     HRM(areaToFillBrush->SetTileMode(XPS_TILE_MODE_FLIPXY),
 586         "Could not set tile mode for side of clamp.");
 587     HRM(areaToFillPath->SetFillBrushLocal(areaToFillBrush.get()),
 588         "Could not set brush for side of clamp");
 589
 590     return S_OK;
 591 }
 592
 593 HRESULT SkXPSDevice::cornerOfClamp(const SkRect& areaToFill,
 594                                    const SkColor color,
 595                                    IXpsOMVisualCollection* visuals) {
 596     SkTScopedComPtr<IXpsOMGeometryFigure> areaToFillFigure;
 597     HR(this->createXpsRect(areaToFill, FALSE, TRUE, &areaToFillFigure));
 598
 599     SkTScopedComPtr<IXpsOMPath> areaToFillPath;
 600     HR(this->createPath(areaToFillFigure.get(), visuals, &areaToFillPath));
 601
 602     SkTScopedComPtr<IXpsOMBrush> areaToFillBrush;
 603     HR(this->createXpsSolidColorBrush(color, 0xFF, &areaToFillBrush));
 604     HRM(areaToFillPath->SetFillBrushLocal(areaToFillBrush.get()),
 605         "Could not set brush for corner of clamp.");
 606
 607     return S_OK;
 608 }
 609
 610 static const XPS_TILE_MODE XTM_N  = XPS_TILE_MODE_NONE;
 611 static const XPS_TILE_MODE XTM_T  = XPS_TILE_MODE_TILE;
 612 static const XPS_TILE_MODE XTM_X  = XPS_TILE_MODE_FLIPX;
 613 static const XPS_TILE_MODE XTM_Y  = XPS_TILE_MODE_FLIPY;
 614 static const XPS_TILE_MODE XTM_XY = XPS_TILE_MODE_FLIPXY;
 615
 616 //TODO(bungeman): In the future, should skia add None,
 617 //handle None+Mirror and None+Repeat correctly.
 618 //None is currently an internal hack so masks don't repeat (None+None only).
 619 static XPS_TILE_MODE SkToXpsTileMode[SkShader::kTileModeCount+1]
 620                                     [SkShader::kTileModeCount+1] = {
 621            //Clamp //Repeat //Mirror //None
 622 /*Clamp */ XTM_N,  XTM_T,   XTM_Y,   XTM_N,
 623 /*Repeat*/ XTM_T,  XTM_T,   XTM_Y,   XTM_N,
 624 /*Mirror*/ XTM_X,  XTM_X,   XTM_XY,  XTM_X,
 625 /*None  */ XTM_N,  XTM_N,   XTM_Y,   XTM_N,
 626 };
 627
 628 HRESULT SkXPSDevice::createXpsImageBrush(
 629         const SkBitmap& bitmap,
 630         const SkMatrix& localMatrix,
 631         const SkShader::TileMode (&xy)[2],
 632         const SkAlpha alpha,
 633         IXpsOMTileBrush** xpsBrush) {
 634     SkDynamicMemoryWStream write;
 635     if (!SkImageEncoder::EncodeStream(&write, bitmap,
 636                                       SkImageEncoder::kPNG_Type, 100)) {
 637         HRM(E_FAIL, "Unable to encode bitmap as png.");
 638     }
 639     SkMemoryStream* read = new SkMemoryStream;
 640     read->setData(write.copyToData())->unref();
 641     SkTScopedComPtr<IStream> readWrapper;
 642     HRM(SkIStream::CreateFromSkStream(read, true, &readWrapper),
 643         "Could not create stream from png data.");
 644
 645     const size_t size =
 646         SK_ARRAY_COUNT(L"/Documents/1/Resources/Images/" L_GUID_ID L".png");
 647     wchar_t buffer[size];
 648     wchar_t id[GUID_ID_LEN];
 649     HR(create_id(id, GUID_ID_LEN));
 650     swprintf_s(buffer, size, L"/Documents/1/Resources/Images/%s.png", id);
 651
 652     SkTScopedComPtr<IOpcPartUri> imagePartUri;
 653     HRM(this->fXpsFactory->CreatePartUri(buffer, &imagePartUri),
 654         "Could not create image part uri.");
 655
 656     SkTScopedComPtr<IXpsOMImageResource> imageResource;
 657     HRM(this->fXpsFactory->CreateImageResource(
 658             readWrapper.get(),
 659             XPS_IMAGE_TYPE_PNG,
 660             imagePartUri.get(),
 661             &imageResource),
 662         "Could not create image resource.");
 663
 664     XPS_RECT bitmapRect = {
 665         0.0, 0.0,
 666         static_cast<FLOAT>(bitmap.width()), static_cast<FLOAT>(bitmap.height())
 667     };
 668     SkTScopedComPtr<IXpsOMImageBrush> xpsImageBrush;
 669     HRM(this->fXpsFactory->CreateImageBrush(imageResource.get(),
 670                                             &bitmapRect, &bitmapRect,
 671                                             &xpsImageBrush),
 672         "Could not create image brush.");
 673
 674     if (SkShader::kClamp_TileMode != xy[0] &&
 675         SkShader::kClamp_TileMode != xy[1]) {
 676
 677         HRM(xpsImageBrush->SetTileMode(SkToXpsTileMode[xy[0]][xy[1]]),
 678             "Could not set image tile mode");
 679         HRM(xpsImageBrush->SetOpacity(alpha / 255.0f),
 680             "Could not set image opacity.");
 681         HRM(xpsImageBrush->QueryInterface(xpsBrush), "QI failed.");
 682     } else {
 683         //TODO(bungeman): compute how big this really needs to be.
 684         const SkScalar BIG = SkIntToScalar(1000); //SK_ScalarMax;
 685         const FLOAT BIG_F = SkScalarToFLOAT(BIG);
 686         const SkScalar bWidth = SkIntToScalar(bitmap.width());
 687         const SkScalar bHeight = SkIntToScalar(bitmap.height());
 688
 689         //create brush canvas
 690         SkTScopedComPtr<IXpsOMCanvas> brushCanvas;
 691         HRM(this->fXpsFactory->CreateCanvas(&brushCanvas),
 692             "Could not create image brush canvas.");
 693         SkTScopedComPtr<IXpsOMVisualCollection> brushVisuals;
 694         HRM(brushCanvas->GetVisuals(&brushVisuals),
 695             "Could not get image brush canvas visuals collection.");
 696
 697         //create central figure
 698         const SkRect bitmapPoints = SkRect::MakeLTRB(0, 0, bWidth, bHeight);
 699         SkTScopedComPtr<IXpsOMGeometryFigure> centralFigure;
 700         HR(this->createXpsRect(bitmapPoints, FALSE, TRUE, &centralFigure));
 701
 702         SkTScopedComPtr<IXpsOMPath> centralPath;
 703         HR(this->createPath(centralFigure.get(),
 704                             brushVisuals.get(),
 705                             &centralPath));
 706         HRM(xpsImageBrush->SetTileMode(XPS_TILE_MODE_FLIPXY),
 707             "Could not set tile mode for image brush central path.");
 708         HRM(centralPath->SetFillBrushLocal(xpsImageBrush.get()),
 709             "Could not set fill brush for image brush central path.");
 710
 711         //add left/right
 712         if (SkShader::kClamp_TileMode == xy[0]) {
 713             SkRect leftArea = SkRect::MakeLTRB(-BIG, 0, 0, bHeight);
 714             XPS_RECT leftImageViewBox = {
 715                 0.0, 0.0,
 716                 1.0, static_cast<FLOAT>(bitmap.height()),
 717             };
 718             HR(this->sideOfClamp(leftArea, leftImageViewBox,
 719                                  imageResource.get(),
 720                                  brushVisuals.get()));
 721
 722             SkRect rightArea = SkRect::MakeLTRB(bWidth, 0, BIG, bHeight);
 723             XPS_RECT rightImageViewBox = {
 724                 bitmap.width() - 1.0f, 0.0f,
 725                 1.0f, static_cast<FLOAT>(bitmap.height()),
 726             };
 727             HR(this->sideOfClamp(rightArea, rightImageViewBox,
 728                                  imageResource.get(),
 729                                  brushVisuals.get()));
 730         }
 731
 732         //add top/bottom
 733         if (SkShader::kClamp_TileMode == xy[1]) {
 734             SkRect topArea = SkRect::MakeLTRB(0, -BIG, bWidth, 0);
 735             XPS_RECT topImageViewBox = {
 736                 0.0, 0.0,
 737                 static_cast<FLOAT>(bitmap.width()), 1.0,
 738             };
 739             HR(this->sideOfClamp(topArea, topImageViewBox,
 740                                  imageResource.get(),
 741                                  brushVisuals.get()));
 742
 743             SkRect bottomArea = SkRect::MakeLTRB(0, bHeight, bWidth, BIG);
 744             XPS_RECT bottomImageViewBox = {
 745                 0.0f, bitmap.height() - 1.0f,
 746                 static_cast<FLOAT>(bitmap.width()), 1.0f,
 747             };
 748             HR(this->sideOfClamp(bottomArea, bottomImageViewBox,
 749                                  imageResource.get(),
 750                                  brushVisuals.get()));
 751         }
 752
 753         //add tl, tr, bl, br
 754         if (SkShader::kClamp_TileMode == xy[0] &&
 755             SkShader::kClamp_TileMode == xy[1]) {
 756
 757             SkAutoLockPixels alp(bitmap);
 758
 759             const SkColor tlColor = bitmap.getColor(0,0);
 760             const SkRect tlArea = SkRect::MakeLTRB(-BIG, -BIG, 0, 0);
 761             HR(this->cornerOfClamp(tlArea, tlColor, brushVisuals.get()));
 762
 763             const SkColor trColor = bitmap.getColor(bitmap.width()-1,0);
 764             const SkRect trArea = SkRect::MakeLTRB(bWidth, -BIG, BIG, 0);
 765             HR(this->cornerOfClamp(trArea, trColor, brushVisuals.get()));
 766
 767             const SkColor brColor = bitmap.getColor(bitmap.width()-1,
 768                                                     bitmap.height()-1);
 769             const SkRect brArea = SkRect::MakeLTRB(bWidth, bHeight, BIG, BIG);
 770             HR(this->cornerOfClamp(brArea, brColor, brushVisuals.get()));
 771
 772             const SkColor blColor = bitmap.getColor(0,bitmap.height()-1);
 773             const SkRect blArea = SkRect::MakeLTRB(-BIG, bHeight, 0, BIG);
 774             HR(this->cornerOfClamp(blArea, blColor, brushVisuals.get()));
 775         }
 776
 777         //create visual brush from canvas
 778         XPS_RECT bound = {};
 779         if (SkShader::kClamp_TileMode == xy[0] &&
 780             SkShader::kClamp_TileMode == xy[1]) {
 781
 782             bound.x = BIG_F / -2;
 783             bound.y = BIG_F / -2;
 784             bound.width = BIG_F;
 785             bound.height = BIG_F;
 786         } else if (SkShader::kClamp_TileMode == xy[0]) {
 787             bound.x = BIG_F / -2;
 788             bound.y = 0.0f;
 789             bound.width = BIG_F;
 790             bound.height = static_cast<FLOAT>(bitmap.height());
 791         } else if (SkShader::kClamp_TileMode == xy[1]) {
 792             bound.x = 0;
 793             bound.y = BIG_F / -2;
 794             bound.width = static_cast<FLOAT>(bitmap.width());
 795             bound.height = BIG_F;
 796         }
 797         SkTScopedComPtr<IXpsOMVisualBrush> clampBrush;
 798         HRM(this->fXpsFactory->CreateVisualBrush(&bound, &bound, &clampBrush),
 799             "Could not create visual brush for image brush.");
 800         HRM(clampBrush->SetVisualLocal(brushCanvas.get()),
 801             "Could not set canvas on visual brush for image brush.");
 802         HRM(clampBrush->SetTileMode(SkToXpsTileMode[xy[0]][xy[1]]),
 803             "Could not set tile mode on visual brush for image brush.");
 804         HRM(clampBrush->SetOpacity(alpha / 255.0f),
 805             "Could not set opacity on visual brush for image brush.");
 806
 807         HRM(clampBrush->QueryInterface(xpsBrush), "QI failed.");
 808     }
 809
 810     SkTScopedComPtr<IXpsOMMatrixTransform> xpsMatrixToUse;
 811     HR(this->createXpsTransform(localMatrix, &xpsMatrixToUse));
 812     if (NULL != xpsMatrixToUse.get()) {
 813         HRM((*xpsBrush)->SetTransformLocal(xpsMatrixToUse.get()),
 814             "Could not set transform for image brush.");
 815     } else {
 816         //TODO(bungeman): perspective bitmaps in general.
 817     }
 818
 819     return S_OK;
 820 }
 821
 822 HRESULT SkXPSDevice::createXpsGradientStop(const SkColor skColor,
 823                                            const SkScalar offset,
 824                                            IXpsOMGradientStop** xpsGradStop) {
 825     XPS_COLOR gradStopXpsColor = xps_color(skColor);
 826     HRM(this->fXpsFactory->CreateGradientStop(&gradStopXpsColor,
 827                                               NULL,
 828                                               SkScalarToFLOAT(offset),
 829                                               xpsGradStop),
 830         "Could not create gradient stop.");
 831     return S_OK;
 832 }
 833
 834 HRESULT SkXPSDevice::createXpsLinearGradient(SkShader::GradientInfo info,
 835                                              const SkAlpha alpha,
 836                                              const SkMatrix& localMatrix,
 837                                              IXpsOMMatrixTransform* xpsMatrix,
 838                                              IXpsOMBrush** xpsBrush) {
 839     XPS_POINT startPoint;
 840     XPS_POINT endPoint;
 841     if (NULL != xpsMatrix) {
 842         startPoint = xps_point(info.fPoint[0]);
 843         endPoint = xps_point(info.fPoint[1]);
 844     } else {
 845         transform_offsets(info.fColorOffsets, info.fColorCount,
 846                           info.fPoint[0], info.fPoint[1],
 847                           localMatrix);
 848         startPoint = xps_point(info.fPoint[0], localMatrix);
 849         endPoint = xps_point(info.fPoint[1], localMatrix);
 850     }
 851
 852     SkTScopedComPtr<IXpsOMGradientStop> gradStop0;
 853     HR(createXpsGradientStop(info.fColors[0],
 854                              info.fColorOffsets[0],
 855                              &gradStop0));
 856
 857     SkTScopedComPtr<IXpsOMGradientStop> gradStop1;
 858     HR(createXpsGradientStop(info.fColors[1],
 859                              info.fColorOffsets[1],
 860                              &gradStop1));
 861
 862     SkTScopedComPtr<IXpsOMLinearGradientBrush> gradientBrush;
 863     HRM(this->fXpsFactory->CreateLinearGradientBrush(gradStop0.get(),
 864                                                      gradStop1.get(),
 865                                                      &startPoint,
 866                                                      &endPoint,
 867                                                      &gradientBrush),
 868         "Could not create linear gradient brush.");
 869     if (NULL != xpsMatrix) {
 870         HRM(gradientBrush->SetTransformLocal(xpsMatrix),
 871             "Could not set transform on linear gradient brush.");
 872     }
 873
 874     SkTScopedComPtr<IXpsOMGradientStopCollection> gradStopCollection;
 875     HRM(gradientBrush->GetGradientStops(&gradStopCollection),
 876         "Could not get linear gradient stop collection.");
 877     for (int i = 2; i < info.fColorCount; ++i) {
 878         SkTScopedComPtr<IXpsOMGradientStop> gradStop;
 879         HR(createXpsGradientStop(info.fColors[i],
 880                                  info.fColorOffsets[i],
 881                                  &gradStop));
 882         HRM(gradStopCollection->Append(gradStop.get()),
 883             "Could not add linear gradient stop.");
 884     }
 885
 886     HRM(gradientBrush->SetSpreadMethod(xps_spread_method(info.fTileMode)),
 887         "Could not set spread method of linear gradient.");
 888
 889     HRM(gradientBrush->SetOpacity(alpha / 255.0f),
 890         "Could not set opacity of linear gradient brush.");
 891     HRM(gradientBrush->QueryInterface<IXpsOMBrush>(xpsBrush), "QI failed");
 892
 893     return S_OK;
 894 }
 895
 896 HRESULT SkXPSDevice::createXpsRadialGradient(SkShader::GradientInfo info,
 897                                              const SkAlpha alpha,
 898                                              const SkMatrix& localMatrix,
 899                                              IXpsOMMatrixTransform* xpsMatrix,
 900                                              IXpsOMBrush** xpsBrush) {
 901     SkTScopedComPtr<IXpsOMGradientStop> gradStop0;
 902     HR(createXpsGradientStop(info.fColors[0],
 903                              info.fColorOffsets[0],
 904                              &gradStop0));
 905
 906     SkTScopedComPtr<IXpsOMGradientStop> gradStop1;
 907     HR(createXpsGradientStop(info.fColors[1],
 908                              info.fColorOffsets[1],
 909                              &gradStop1));
 910
 911     //TODO: figure out how to fake better if not affine
 912     XPS_POINT centerPoint;
 913     XPS_POINT gradientOrigin;
 914     XPS_SIZE radiiSizes;
 915     if (NULL != xpsMatrix) {
 916         centerPoint = xps_point(info.fPoint[0]);
 917         gradientOrigin = xps_point(info.fPoint[0]);
 918         radiiSizes.width = SkScalarToFLOAT(info.fRadius[0]);
 919         radiiSizes.height = SkScalarToFLOAT(info.fRadius[0]);
 920     } else {
 921         centerPoint = xps_point(info.fPoint[0], localMatrix);
 922         gradientOrigin = xps_point(info.fPoint[0], localMatrix);
 923
 924         SkScalar radius = info.fRadius[0];
 925         SkVector vec[2];
 926
 927         vec[0].set(radius, 0);
 928         vec[1].set(0, radius);
 929         localMatrix.mapVectors(vec, 2);
 930
 931         SkScalar d0 = vec[0].length();
 932         SkScalar d1 = vec[1].length();
 933
 934         radiiSizes.width = SkScalarToFLOAT(d0);
 935         radiiSizes.height = SkScalarToFLOAT(d1);
 936     }
 937
 938     SkTScopedComPtr<IXpsOMRadialGradientBrush> gradientBrush;
 939     HRM(this->fXpsFactory->CreateRadialGradientBrush(gradStop0.get(),
 940                                                      gradStop1.get(),
 941                                                      &centerPoint,
 942                                                      &gradientOrigin,
 943                                                      &radiiSizes,
 944                                                      &gradientBrush),
 945         "Could not create radial gradient brush.");
 946     if (NULL != xpsMatrix) {
 947         HRM(gradientBrush->SetTransformLocal(xpsMatrix),
 948             "Could not set transform on radial gradient brush.");
 949     }
 950
 951     SkTScopedComPtr<IXpsOMGradientStopCollection> gradStopCollection;
 952     HRM(gradientBrush->GetGradientStops(&gradStopCollection),
 953         "Could not get radial gradient stop collection.");
 954     for (int i = 2; i < info.fColorCount; ++i) {
 955         SkTScopedComPtr<IXpsOMGradientStop> gradStop;
 956         HR(createXpsGradientStop(info.fColors[i],
 957                                  info.fColorOffsets[i],
 958                                  &gradStop));
 959         HRM(gradStopCollection->Append(gradStop.get()),
 960             "Could not add radial gradient stop.");
 961     }
 962
 963     HRM(gradientBrush->SetSpreadMethod(xps_spread_method(info.fTileMode)),
 964         "Could not set spread method of radial gradient.");
 965
 966     HRM(gradientBrush->SetOpacity(alpha / 255.0f),
 967         "Could not set opacity of radial gradient brush.");
 968     HRM(gradientBrush->QueryInterface<IXpsOMBrush>(xpsBrush), "QI failed.");
 969
 970     return S_OK;
 971 }
 972
 973 HRESULT SkXPSDevice::createXpsBrush(const SkPaint& skPaint,
 974                                     IXpsOMBrush** brush,
 975                                     const SkMatrix* parentTransform) {
 976     const SkShader *shader = skPaint.getShader();
 977     if (NULL == shader) {
 978         HR(this->createXpsSolidColorBrush(skPaint.getColor(), 0xFF, brush));
 979         return S_OK;
 980     }
 981
 982     //Gradient shaders.
 983     SkShader::GradientInfo info;
 984     info.fColorCount = 0;
 985     info.fColors = NULL;
 986     info.fColorOffsets = NULL;
 987     SkShader::GradientType gradientType = shader->asAGradient(&info);
 988
 989     if (SkShader::kNone_GradientType == gradientType) {
 990         //Nothing to see, move along.
 991
 992     } else if (SkShader::kColor_GradientType == gradientType) {
 993         SkASSERT(1 == info.fColorCount);
 994         SkColor color;
 995         info.fColors = &color;
 996         shader->asAGradient(&info);
 997         SkAlpha alpha = skPaint.getAlpha();
 998         HR(this->createXpsSolidColorBrush(color, alpha, brush));
 999         return S_OK;
1000
1001     } else {
1002         if (info.fColorCount == 0) {
1003             const SkColor color = skPaint.getColor();
1004             HR(this->createXpsSolidColorBrush(color, 0xFF, brush));
1005             return S_OK;
1006         }
1007
1008         SkAutoTArray<SkColor> colors(info.fColorCount);
1009         SkAutoTArray<SkScalar> colorOffsets(info.fColorCount);
1010         info.fColors = colors.get();
1011         info.fColorOffsets = colorOffsets.get();
1012         shader->asAGradient(&info);
1013
1014         if (1 == info.fColorCount) {
1015             SkColor color = info.fColors[0];
1016             SkAlpha alpha = skPaint.getAlpha();
1017             HR(this->createXpsSolidColorBrush(color, alpha, brush));
1018             return S_OK;
1019         }
1020
1021         SkMatrix localMatrix = shader->getLocalMatrix();
1022         if (NULL != parentTransform) {
1023             localMatrix.preConcat(*parentTransform);
1024         }
1025         SkTScopedComPtr<IXpsOMMatrixTransform> xpsMatrixToUse;
1026         HR(this->createXpsTransform(localMatrix, &xpsMatrixToUse));
1027
1028         if (SkShader::kLinear_GradientType == gradientType) {
1029             HR(this->createXpsLinearGradient(info,
1030                                              skPaint.getAlpha(),
1031                                              localMatrix,
1032                                              xpsMatrixToUse.get(),
1033                                              brush));
1034             return S_OK;
1035         }
1036
1037         if (SkShader::kRadial_GradientType == gradientType) {
1038             HR(this->createXpsRadialGradient(info,
1039                                              skPaint.getAlpha(),
1040                                              localMatrix,
1041                                              xpsMatrixToUse.get(),
1042                                              brush));
1043             return S_OK;
1044         }
1045
1046         if (SkShader::kRadial2_GradientType == gradientType ||
1047             SkShader::kConical_GradientType == gradientType) {
1048             //simple if affine and one is 0, otherwise will have to fake
1049         }
1050
1051         if (SkShader::kSweep_GradientType == gradientType) {
1052             //have to fake
1053         }
1054     }
1055
1056     SkBitmap outTexture;
1057     SkMatrix outMatrix;
1058     SkShader::TileMode xy[2];
1059     SkShader::BitmapType bitmapType = shader->asABitmap(&outTexture,
1060                                                         &outMatrix,
1061                                                         xy);
1062     switch (bitmapType) {
1063         case SkShader::kNone_BitmapType:
1064             break;
1065         case SkShader::kDefault_BitmapType: {
1066             //TODO: outMatrix??
1067             SkMatrix localMatrix = shader->getLocalMatrix();
1068             if (NULL != parentTransform) {
1069                 localMatrix.preConcat(*parentTransform);
1070             }
1071
1072             SkTScopedComPtr<IXpsOMTileBrush> tileBrush;
1073             HR(this->createXpsImageBrush(outTexture,
1074                                          localMatrix,
1075                                          xy,
1076                                          skPaint.getAlpha(),
1077                                          &tileBrush));
1078
1079             HRM(tileBrush->QueryInterface<IXpsOMBrush>(brush), "QI failed.");
1080
1081             return S_OK;
1082         }
1083         case SkShader::kRadial_BitmapType:
1084         case SkShader::kSweep_BitmapType:
1085         case SkShader::kTwoPointRadial_BitmapType:
1086         default:
1087             break;
1088     }
1089
1090     HR(this->createXpsSolidColorBrush(skPaint.getColor(), 0xFF, brush));
1091     return S_OK;
1092 }
1093
1094 static bool rect_must_be_pathed(const SkPaint& paint, const SkMatrix& matrix) {
1095     const bool zeroWidth = (0 == paint.getStrokeWidth());
1096     const bool stroke = (SkPaint::kFill_Style != paint.getStyle());
1097
1098     return paint.getPathEffect() ||
1099            paint.getMaskFilter() ||
1100            paint.getRasterizer() ||
1101            (stroke && (
1102                (matrix.hasPerspective() && !zeroWidth) ||
1103                SkPaint::kMiter_Join != paint.getStrokeJoin() ||
1104                (SkPaint::kMiter_Join == paint.getStrokeJoin() &&
1105                 paint.getStrokeMiter() < SK_ScalarSqrt2)
1106            ))
1107     ;
1108 }
1109
1110 HRESULT SkXPSDevice::createXpsRect(const SkRect& rect, BOOL stroke, BOOL fill,
1111                                    IXpsOMGeometryFigure** xpsRect) {
1112     const SkPoint points[4] = {
1113         { rect.fLeft, rect.fTop },
1114         { rect.fRight, rect.fTop },
1115         { rect.fRight, rect.fBottom },
1116         { rect.fLeft, rect.fBottom },
1117     };
1118     return this->createXpsQuad(points, stroke, fill, xpsRect);
1119 }
1120 HRESULT SkXPSDevice::createXpsQuad(const SkPoint (&points)[4],
1121                                    BOOL stroke, BOOL fill,
1122                                    IXpsOMGeometryFigure** xpsQuad) {
1123     // Define the start point.
1124     XPS_POINT startPoint = xps_point(points[0]);
1125
1126     // Create the figure.
1127     HRM(this->fXpsFactory->CreateGeometryFigure(&startPoint, xpsQuad),
1128         "Could not create quad geometry figure.");
1129
1130     // Define the type of each segment.
1131     XPS_SEGMENT_TYPE segmentTypes[3] = {
1132         XPS_SEGMENT_TYPE_LINE,
1133         XPS_SEGMENT_TYPE_LINE,
1134         XPS_SEGMENT_TYPE_LINE,
1135     };
1136
1137     // Define the x and y coordinates of each corner of the figure.
1138     FLOAT segmentData[6] = {
1139         SkScalarToFLOAT(points[1].fX), SkScalarToFLOAT(points[1].fY),
1140         SkScalarToFLOAT(points[2].fX), SkScalarToFLOAT(points[2].fY),
1141         SkScalarToFLOAT(points[3].fX), SkScalarToFLOAT(points[3].fY),
1142     };
1143
1144     // Describe if the segments are stroked.
1145     BOOL segmentStrokes[3] = {
1146         stroke, stroke, stroke,
1147     };
1148
1149     // Add the segment data to the figure.
1150     HRM((*xpsQuad)->SetSegments(
1151             3, 6,
1152             segmentTypes , segmentData, segmentStrokes),
1153         "Could not add segment data to quad.");
1154
1155     // Set the closed and filled properties of the figure.
1156     HRM((*xpsQuad)->SetIsClosed(stroke), "Could not set quad close.");
1157     HRM((*xpsQuad)->SetIsFilled(fill), "Could not set quad fill.");
1158
1159     return S_OK;
1160 }
1161
1162 uint32_t SkXPSDevice::getDeviceCapabilities() {
1163     return kVector_Capability;
1164 }
1165
1166 void SkXPSDevice::clear(SkColor color) {
1167     //TODO: override this for XPS
1168     SkDEBUGF(("XPS clear not yet implemented."));
1169 }
1170
1171 void SkXPSDevice::drawPoints(const SkDraw& d, SkCanvas::PointMode mode,
1172                              size_t count, const SkPoint points[],
1173                              const SkPaint& paint) {
1174     //This will call back into the device to do the drawing.
1175     d.drawPoints(mode, count, points, paint, true);
1176 }
1177
1178 void SkXPSDevice::drawVertices(const SkDraw&, SkCanvas::VertexMode,
1179                                int vertexCount, const SkPoint verts[],
1180                                const SkPoint texs[], const SkColor colors[],
1181                                SkXfermode* xmode, const uint16_t indices[],
1182                                int indexCount, const SkPaint& paint) {
1183     //TODO: override this for XPS
1184     SkDEBUGF(("XPS drawVertices not yet implemented."));
1185 }
1186
1187 void SkXPSDevice::drawPaint(const SkDraw& d, const SkPaint& origPaint) {
1188     const SkRect r = SkRect::MakeSize(this->fCurrentCanvasSize);
1189
1190     //If trying to paint with a stroke, ignore that and fill.
1191     SkPaint* fillPaint = const_cast<SkPaint*>(&origPaint);
1192     SkTCopyOnFirstWrite<SkPaint> paint(origPaint);
1193     if (paint->getStyle() != SkPaint::kFill_Style) {
1194         paint.writable()->setStyle(SkPaint::kFill_Style);
1195     }
1196
1197     this->internalDrawRect(d, r, false, *fillPaint);
1198 }
1199
1200 void SkXPSDevice::drawRect(const SkDraw& d,
1201                            const SkRect& r,
1202                            const SkPaint& paint) {
1203     this->internalDrawRect(d, r, true, paint);
1204 }
1205
1206 void SkXPSDevice::drawRRect(const SkDraw& d,
1207                             const SkRRect& rr,
1208                             const SkPaint& paint) {
1209     SkPath path;
1210     path.addRRect(rr);
1211     this->drawPath(d, path, paint, NULL, true);
1212 }
1213
1214 void SkXPSDevice::internalDrawRect(const SkDraw& d,
1215                                    const SkRect& r,
1216                                    bool transformRect,
1217                                    const SkPaint& paint) {
1218     //Exit early if there is nothing to draw.
1219     if (d.fClip->isEmpty() ||
1220         (paint.getAlpha() == 0 && paint.getXfermode() == NULL)) {
1221         return;
1222     }
1223
1224     //Path the rect if we can't optimize it.
1225     if (rect_must_be_pathed(paint, *d.fMatrix)) {
1226         SkPath tmp;
1227         tmp.addRect(r);
1228         tmp.setFillType(SkPath::kWinding_FillType);
1229         this->drawPath(d, tmp, paint, NULL, true);
1230         return;
1231     }
1232
1233     //Create the shaded path.
1234     SkTScopedComPtr<IXpsOMPath> shadedPath;
1235     HRVM(this->fXpsFactory->CreatePath(&shadedPath),
1236          "Could not create shaded path for rect.");
1237
1238     //Create the shaded geometry.
1239     SkTScopedComPtr<IXpsOMGeometry> shadedGeometry;
1240     HRVM(this->fXpsFactory->CreateGeometry(&shadedGeometry),
1241          "Could not create shaded geometry for rect.");
1242
1243     //Add the geometry to the shaded path.
1244     HRVM(shadedPath->SetGeometryLocal(shadedGeometry.get()),
1245          "Could not set shaded geometry for rect.");
1246
1247     //Set the brushes.
1248     BOOL fill = FALSE;
1249     BOOL stroke = FALSE;
1250     HRV(this->shadePath(shadedPath.get(), paint, *d.fMatrix, &fill, &stroke));
1251
1252     bool xpsTransformsPath = true;
1253     //Transform the geometry.
1254     if (transformRect && xpsTransformsPath) {
1255         SkTScopedComPtr<IXpsOMMatrixTransform> xpsTransform;
1256         HRV(this->createXpsTransform(*d.fMatrix, &xpsTransform));
1257         if (xpsTransform.get()) {
1258             HRVM(shadedGeometry->SetTransformLocal(xpsTransform.get()),
1259                  "Could not set transform for rect.");
1260         } else {
1261             xpsTransformsPath = false;
1262         }
1263     }
1264
1265     //Create the figure.
1266     SkTScopedComPtr<IXpsOMGeometryFigure> rectFigure;
1267     {
1268         SkPoint points[4] = {
1269             { r.fLeft, r.fTop },
1270             { r.fLeft, r.fBottom },
1271             { r.fRight, r.fBottom },
1272             { r.fRight, r.fTop },
1273         };
1274         if (!xpsTransformsPath && transformRect) {
1275             d.fMatrix->mapPoints(points, SK_ARRAY_COUNT(points));
1276         }
1277         HRV(this->createXpsQuad(points, stroke, fill, &rectFigure));
1278     }
1279
1280     //Get the figures of the shaded geometry.
1281     SkTScopedComPtr<IXpsOMGeometryFigureCollection> shadedFigures;
1282     HRVM(shadedGeometry->GetFigures(&shadedFigures),
1283          "Could not get shaded figures for rect.");
1284
1285     //Add the figure to the shaded geometry figures.
1286     HRVM(shadedFigures->Append(rectFigure.get()),
1287          "Could not add shaded figure for rect.");
1288
1289     HRV(this->clip(shadedPath.get(), d));
1290
1291     //Add the shaded path to the current visuals.
1292     SkTScopedComPtr<IXpsOMVisualCollection> currentVisuals;
1293     HRVM(this->fCurrentXpsCanvas->GetVisuals(&currentVisuals),
1294          "Could not get current visuals for rect.");
1295     HRVM(currentVisuals->Append(shadedPath.get()),
1296          "Could not add rect to current visuals.");
1297 }
1298
1299 static HRESULT close_figure(const SkTDArray<XPS_SEGMENT_TYPE>& segmentTypes,
1300                             const SkTDArray<BOOL>& segmentStrokes,
1301                             const SkTDArray<FLOAT>& segmentData,
1302                             BOOL stroke, BOOL fill,
1303                             IXpsOMGeometryFigure* figure,
1304                             IXpsOMGeometryFigureCollection* figures) {
1305     // Add the segment data to the figure.
1306     HRM(figure->SetSegments(segmentTypes.count(), segmentData.count(),
1307                             segmentTypes.begin() , segmentData.begin(),
1308                             segmentStrokes.begin()),
1309         "Could not set path segments.");
1310
1311     // Set the closed and filled properties of the figure.
1312     HRM(figure->SetIsClosed(stroke), "Could not set path closed.");
1313     HRM(figure->SetIsFilled(fill), "Could not set path fill.");
1314
1315     // Add the figure created above to this geometry.
1316     HRM(figures->Append(figure), "Could not add path to geometry.");
1317     return S_OK;
1318 }
1319
1320 HRESULT SkXPSDevice::addXpsPathGeometry(
1321         IXpsOMGeometryFigureCollection* xpsFigures,
1322         BOOL stroke, BOOL fill, const SkPath& path) {
1323     SkTDArray<XPS_SEGMENT_TYPE> segmentTypes;
1324     SkTDArray<BOOL> segmentStrokes;
1325     SkTDArray<FLOAT> segmentData;
1326
1327     SkTScopedComPtr<IXpsOMGeometryFigure> xpsFigure;
1328     SkPath::Iter iter(path, true);
1329     SkPoint points[4];
1330     SkPath::Verb verb;
1331     while ((verb = iter.next(points)) != SkPath::kDone_Verb) {
1332         switch (verb) {
1333             case SkPath::kMove_Verb: {
1334                 if (NULL != xpsFigure.get()) {
1335                     HR(close_figure(segmentTypes, segmentStrokes, segmentData,
1336                                     stroke, fill,
1337                                     xpsFigure.get() , xpsFigures));
1338                     xpsFigure.reset();
1339                     segmentTypes.rewind();
1340                     segmentStrokes.rewind();
1341                     segmentData.rewind();
1342                 }
1343                 // Define the start point.
1344                 XPS_POINT startPoint = xps_point(points[0]);
1345                 // Create the figure.
1346                 HRM(this->fXpsFactory->CreateGeometryFigure(&startPoint,
1347                                                             &xpsFigure),
1348                     "Could not create path geometry figure.");
1349                 break;
1350             }
1351             case SkPath::kLine_Verb:
1352                 if (iter.isCloseLine()) break; //ignore the line, auto-closed
1353                 segmentTypes.push(XPS_SEGMENT_TYPE_LINE);
1354                 segmentStrokes.push(stroke);
1355                 segmentData.push(SkScalarToFLOAT(points[1].fX));
1356                 segmentData.push(SkScalarToFLOAT(points[1].fY));
1357                 break;
1358             case SkPath::kQuad_Verb:
1359                 segmentTypes.push(XPS_SEGMENT_TYPE_QUADRATIC_BEZIER);
1360                 segmentStrokes.push(stroke);
1361                 segmentData.push(SkScalarToFLOAT(points[1].fX));
1362                 segmentData.push(SkScalarToFLOAT(points[1].fY));
1363                 segmentData.push(SkScalarToFLOAT(points[2].fX));
1364                 segmentData.push(SkScalarToFLOAT(points[2].fY));
1365                 break;
1366             case SkPath::kCubic_Verb:
1367                 segmentTypes.push(XPS_SEGMENT_TYPE_BEZIER);
1368                 segmentStrokes.push(stroke);
1369                 segmentData.push(SkScalarToFLOAT(points[1].fX));
1370                 segmentData.push(SkScalarToFLOAT(points[1].fY));
1371                 segmentData.push(SkScalarToFLOAT(points[2].fX));
1372                 segmentData.push(SkScalarToFLOAT(points[2].fY));
1373                 segmentData.push(SkScalarToFLOAT(points[3].fX));
1374                 segmentData.push(SkScalarToFLOAT(points[3].fY));
1375                 break;
1376             case SkPath::kClose_Verb:
1377                 // we ignore these, and just get the whole segment from
1378                 // the corresponding line/quad/cubic verbs
1379                 break;
1380             default:
1381                 SkDEBUGFAIL("unexpected verb");
1382                 break;
1383         }
1384     }
1385     if (NULL != xpsFigure.get()) {
1386         HR(close_figure(segmentTypes, segmentStrokes, segmentData,
1387                         stroke, fill,
1388                         xpsFigure.get(), xpsFigures));
1389     }
1390     return S_OK;
1391 }
1392
1393 HRESULT SkXPSDevice::drawInverseWindingPath(const SkDraw& d,
1394                                             const SkPath& devicePath,
1395                                             IXpsOMPath* shadedPath) {
1396     const SkRect universeRect = SkRect::MakeLTRB(0, 0,
1397         this->fCurrentCanvasSize.fWidth, this->fCurrentCanvasSize.fHeight);
1398
1399     const XPS_RECT universeRectXps = {
1400         0.0f, 0.0f,
1401         SkScalarToFLOAT(this->fCurrentCanvasSize.fWidth),
1402         SkScalarToFLOAT(this->fCurrentCanvasSize.fHeight),
1403     };
1404
1405     //Get the geometry.
1406     SkTScopedComPtr<IXpsOMGeometry> shadedGeometry;
1407     HRM(shadedPath->GetGeometry(&shadedGeometry),
1408         "Could not get shaded geometry for inverse path.");
1409
1410     //Get the figures from the geometry.
1411     SkTScopedComPtr<IXpsOMGeometryFigureCollection> shadedFigures;
1412     HRM(shadedGeometry->GetFigures(&shadedFigures),
1413         "Could not get shaded figures for inverse path.");
1414
1415     HRM(shadedGeometry->SetFillRule(XPS_FILL_RULE_NONZERO),
1416         "Could not set shaded fill rule for inverse path.");
1417
1418     //Take everything drawn so far, and make a shared resource out of it.
1419     //Replace everything drawn so far with
1420     //inverse canvas
1421     //  old canvas of everything so far
1422     //  world shaded figure, clipped to current clip
1423     //  top canvas of everything so far, clipped to path
1424     //Note: this is not quite right when there is nothing solid in the
1425     //canvas of everything so far, as the bit on top will allow
1426     //the world paint to show through.
1427
1428     //Create new canvas.
1429     SkTScopedComPtr<IXpsOMCanvas> newCanvas;
1430     HRM(this->fXpsFactory->CreateCanvas(&newCanvas),
1431         "Could not create inverse canvas.");
1432
1433     //Save the old canvas to a dictionary on the new canvas.
1434     SkTScopedComPtr<IXpsOMDictionary> newDictionary;
1435     HRM(this->fXpsFactory->CreateDictionary(&newDictionary),
1436         "Could not create inverse dictionary.");
1437     HRM(newCanvas->SetDictionaryLocal(newDictionary.get()),
1438         "Could not set inverse dictionary.");
1439
1440     const size_t size = SK_ARRAY_COUNT(L"ID" L_GUID_ID);
1441     wchar_t buffer[size];
1442     wchar_t id[GUID_ID_LEN];
1443     HR(create_id(id, GUID_ID_LEN, '_'));
1444     swprintf_s(buffer, size, L"ID%s", id);
1445     HRM(newDictionary->Append(buffer, this->fCurrentXpsCanvas.get()),
1446         "Could not add canvas to inverse dictionary.");
1447
1448     //Start drawing
1449     SkTScopedComPtr<IXpsOMVisualCollection> newVisuals;
1450     HRM(newCanvas->GetVisuals(&newVisuals),
1451         "Could not get inverse canvas visuals.");
1452
1453     //Draw old canvas from dictionary onto new canvas.
1454     SkTScopedComPtr<IXpsOMGeometry> oldGeometry;
1455     HRM(this->fXpsFactory->CreateGeometry(&oldGeometry),
1456         "Could not create old inverse geometry.");
1457
1458     SkTScopedComPtr<IXpsOMGeometryFigureCollection> oldFigures;
1459     HRM(oldGeometry->GetFigures(&oldFigures),
1460         "Could not get old inverse figures.");
1461
1462     SkTScopedComPtr<IXpsOMGeometryFigure> oldFigure;
1463     HR(this->createXpsRect(universeRect, FALSE, TRUE, &oldFigure));
1464     HRM(oldFigures->Append(oldFigure.get()),
1465         "Could not add old inverse figure.");
1466
1467     SkTScopedComPtr<IXpsOMVisualBrush> oldBrush;
1468     HRM(this->fXpsFactory->CreateVisualBrush(&universeRectXps,
1469                                              &universeRectXps,
1470                                              &oldBrush),
1471         "Could not create old inverse brush.");
1472
1473     SkTScopedComPtr<IXpsOMPath> oldPath;
1474     HRM(this->fXpsFactory->CreatePath(&oldPath),
1475         "Could not create old inverse path.");
1476     HRM(oldPath->SetGeometryLocal(oldGeometry.get()),
1477         "Could not set old inverse geometry.");
1478     HRM(oldPath->SetFillBrushLocal(oldBrush.get()),
1479         "Could not set old inverse fill brush.");
1480     //the brush must be parented before setting the lookup.
1481     HRM(newVisuals->Append(oldPath.get()),
1482         "Could not add old inverse path to new canvas visuals.");
1483     HRM(oldBrush->SetVisualLookup(buffer),
1484         "Could not set old inverse brush visual lookup.");
1485
1486     //Draw the clip filling shader.
1487     SkTScopedComPtr<IXpsOMGeometryFigure> shadedFigure;
1488     HR(this->createXpsRect(universeRect, FALSE, TRUE, &shadedFigure));
1489     HRM(shadedFigures->Append(shadedFigure.get()),
1490         "Could not add inverse shaded figure.");
1491     //the geometry is already set
1492     HR(this->clip(shadedPath, d));
1493     HRM(newVisuals->Append(shadedPath),
1494         "Could not add inverse shaded path to canvas visuals.");
1495
1496     //Draw the old canvas on top, clipped to the original path.
1497     SkTScopedComPtr<IXpsOMCanvas> topCanvas;
1498     HRM(this->fXpsFactory->CreateCanvas(&topCanvas),
1499         "Could not create top inverse canvas.");
1500     //Clip the canvas to prevent alpha spill.
1501     //This is the entire reason this canvas exists.
1502     HR(this->clip(topCanvas.get(), d));
1503
1504     SkTScopedComPtr<IXpsOMGeometry> topGeometry;
1505     HRM(this->fXpsFactory->CreateGeometry(&topGeometry),
1506         "Could not create top inverse geometry.");
1507
1508     SkTScopedComPtr<IXpsOMGeometryFigureCollection> topFigures;
1509     HRM(topGeometry->GetFigures(&topFigures),
1510         "Could not get top inverse figures.");
1511
1512     SkTScopedComPtr<IXpsOMGeometryFigure> topFigure;
1513     HR(this->createXpsRect(universeRect, FALSE, TRUE, &topFigure));
1514     HRM(topFigures->Append(topFigure.get()),
1515         "Could not add old inverse figure.");
1516
1517     SkTScopedComPtr<IXpsOMVisualBrush> topBrush;
1518     HRM(this->fXpsFactory->CreateVisualBrush(&universeRectXps,
1519                                              &universeRectXps,
1520                                              &topBrush),
1521         "Could not create top inverse brush.");
1522
1523     SkTScopedComPtr<IXpsOMPath> topPath;
1524     HRM(this->fXpsFactory->CreatePath(&topPath),
1525         "Could not create top inverse path.");
1526     HRM(topPath->SetGeometryLocal(topGeometry.get()),
1527         "Could not set top inverse geometry.");
1528     HRM(topPath->SetFillBrushLocal(topBrush.get()),
1529         "Could not set top inverse fill brush.");
1530     //the brush must be parented before setting the lookup.
1531     HRM(newVisuals->Append(topCanvas.get()),
1532         "Could not add top canvas to inverse canvas visuals.");
1533     SkTScopedComPtr<IXpsOMVisualCollection> topVisuals;
1534     HRM(topCanvas->GetVisuals(&topVisuals),
1535         "Could not get top inverse canvas visuals.");
1536     HRM(topVisuals->Append(topPath.get()),
1537         "Could not add top inverse path to top canvas visuals.");
1538     HRM(topBrush->SetVisualLookup(buffer),
1539         "Could not set top inverse brush visual lookup.");
1540
1541     HR(this->clipToPath(topPath.get(), devicePath, XPS_FILL_RULE_NONZERO));
1542
1543     //swap current canvas to new canvas
1544     this->fCurrentXpsCanvas.swap(newCanvas);
1545
1546     return S_OK;
1547 }
1548
1549 void SkXPSDevice::convertToPpm(const SkMaskFilter* filter,
1550                                SkMatrix* matrix,
1551                                SkVector* ppuScale,
1552                                const SkIRect& clip, SkIRect* clipIRect) {
1553     //This action is in unit space, but the ppm is specified in physical space.
1554     ppuScale->fX = SkScalarDiv(this->fCurrentPixelsPerMeter.fX,
1555                                this->fCurrentUnitsPerMeter.fX);
1556     ppuScale->fY = SkScalarDiv(this->fCurrentPixelsPerMeter.fY,
1557                                this->fCurrentUnitsPerMeter.fY);
1558
1559     matrix->postScale(ppuScale->fX, ppuScale->fY);
1560
1561     const SkIRect& irect = clip;
1562     SkRect clipRect = SkRect::MakeLTRB(
1563         SkScalarMul(SkIntToScalar(irect.fLeft), ppuScale->fX),
1564         SkScalarMul(SkIntToScalar(irect.fTop), ppuScale->fY),
1565         SkScalarMul(SkIntToScalar(irect.fRight), ppuScale->fX),
1566         SkScalarMul(SkIntToScalar(irect.fBottom), ppuScale->fY));
1567     clipRect.roundOut(clipIRect);
1568 }
1569
1570 HRESULT SkXPSDevice::applyMask(const SkDraw& d,
1571                                const SkMask& mask,
1572                                const SkVector& ppuScale,
1573                                IXpsOMPath* shadedPath) {
1574     //Get the geometry object.
1575     SkTScopedComPtr<IXpsOMGeometry> shadedGeometry;
1576     HRM(shadedPath->GetGeometry(&shadedGeometry),
1577         "Could not get mask shaded geometry.");
1578
1579     //Get the figures from the geometry.
1580     SkTScopedComPtr<IXpsOMGeometryFigureCollection> shadedFigures;
1581     HRM(shadedGeometry->GetFigures(&shadedFigures),
1582         "Could not get mask shaded figures.");
1583
1584     SkMatrix m;
1585     m.reset();
1586     m.setTranslate(SkIntToScalar(mask.fBounds.fLeft),
1587                    SkIntToScalar(mask.fBounds.fTop));
1588     m.postScale(SkScalarInvert(ppuScale.fX), SkScalarInvert(ppuScale.fY));
1589
1590     SkShader::TileMode xy[2];
1591     xy[0] = (SkShader::TileMode)3;
1592     xy[1] = (SkShader::TileMode)3;
1593
1594     SkBitmap bm;
1595     bm.setConfig(SkBitmap::kA8_Config,
1596                  mask.fBounds.width(),
1597                  mask.fBounds.height(),
1598                  mask.fRowBytes);
1599     bm.setPixels(mask.fImage);
1600
1601     SkTScopedComPtr<IXpsOMTileBrush> maskBrush;
1602     HR(this->createXpsImageBrush(bm, m, xy, 0xFF, &maskBrush));
1603     HRM(shadedPath->SetOpacityMaskBrushLocal(maskBrush.get()),
1604         "Could not set mask.");
1605
1606     const SkRect universeRect = SkRect::MakeLTRB(0, 0,
1607         this->fCurrentCanvasSize.fWidth, this->fCurrentCanvasSize.fHeight);
1608     SkTScopedComPtr<IXpsOMGeometryFigure> shadedFigure;
1609     HRM(this->createXpsRect(universeRect, FALSE, TRUE, &shadedFigure),
1610         "Could not create mask shaded figure.");
1611     HRM(shadedFigures->Append(shadedFigure.get()),
1612         "Could not add mask shaded figure.");
1613
1614     HR(this->clip(shadedPath, d));
1615
1616     //Add the path to the active visual collection.
1617     SkTScopedComPtr<IXpsOMVisualCollection> currentVisuals;
1618     HRM(this->fCurrentXpsCanvas->GetVisuals(&currentVisuals),
1619         "Could not get mask current visuals.");
1620     HRM(currentVisuals->Append(shadedPath),
1621         "Could not add masked shaded path to current visuals.");
1622
1623     return S_OK;
1624 }
1625
1626 HRESULT SkXPSDevice::shadePath(IXpsOMPath* shadedPath,
1627                                const SkPaint& shaderPaint,
1628                                const SkMatrix& matrix,
1629                                BOOL* fill, BOOL* stroke) {
1630     *fill = FALSE;
1631     *stroke = FALSE;
1632
1633     const SkPaint::Style style = shaderPaint.getStyle();
1634     const bool hasFill = SkPaint::kFill_Style == style
1635                       || SkPaint::kStrokeAndFill_Style == style;
1636     const bool hasStroke = SkPaint::kStroke_Style == style
1637                         || SkPaint::kStrokeAndFill_Style == style;
1638
1639     //TODO(bungeman): use dictionaries and lookups.
1640     if (hasFill) {
1641         *fill = TRUE;
1642         SkTScopedComPtr<IXpsOMBrush> fillBrush;
1643         HR(this->createXpsBrush(shaderPaint, &fillBrush, &matrix));
1644         HRM(shadedPath->SetFillBrushLocal(fillBrush.get()),
1645             "Could not set fill for shaded path.");
1646     }
1647
1648     if (hasStroke) {
1649         *stroke = TRUE;
1650         SkTScopedComPtr<IXpsOMBrush> strokeBrush;
1651         HR(this->createXpsBrush(shaderPaint, &strokeBrush, &matrix));
1652         HRM(shadedPath->SetStrokeBrushLocal(strokeBrush.get()),
1653             "Could not set stroke brush for shaded path.");
1654         HRM(shadedPath->SetStrokeThickness(
1655                 SkScalarToFLOAT(shaderPaint.getStrokeWidth())),
1656             "Could not set shaded path stroke thickness.");
1657
1658         if (0 == shaderPaint.getStrokeWidth()) {
1659             //XPS hair width is a hack. (XPS Spec 11.6.12).
1660             SkTScopedComPtr<IXpsOMDashCollection> dashes;
1661             HRM(shadedPath->GetStrokeDashes(&dashes),
1662                 "Could not set dashes for shaded path.");
1663             XPS_DASH dash;
1664             dash.length = 1.0;
1665             dash.gap = 0.0;
1666             HRM(dashes->Append(&dash), "Could not add dashes to shaded path.");
1667             HRM(shadedPath->SetStrokeDashOffset(-2.0),
1668                 "Could not set dash offset for shaded path.");
1669         }
1670     }
1671     return S_OK;
1672 }
1673
1674 void SkXPSDevice::drawPath(const SkDraw& d,
1675                            const SkPath& platonicPath,
1676                            const SkPaint& origPaint,
1677                            const SkMatrix* prePathMatrix,
1678                            bool pathIsMutable) {
1679     SkTCopyOnFirstWrite<SkPaint> paint(origPaint);
1680
1681     // nothing to draw
1682     if (d.fClip->isEmpty() ||
1683         (paint->getAlpha() == 0 && paint->getXfermode() == NULL)) {
1684         return;
1685     }
1686
1687     SkPath modifiedPath;
1688     const bool paintHasPathEffect = paint->getPathEffect()
1689                                  || paint->getStyle() != SkPaint::kFill_Style;
1690
1691     //Apply pre-path matrix [Platonic-path -> Skeletal-path].
1692     SkMatrix matrix = *d.fMatrix;
1693     SkPath* skeletalPath = const_cast<SkPath*>(&platonicPath);
1694     if (prePathMatrix) {
1695         if (paintHasPathEffect || paint->getRasterizer()) {
1696             if (!pathIsMutable) {
1697                 skeletalPath = &modifiedPath;
1698                 pathIsMutable = true;
1699             }
1700             platonicPath.transform(*prePathMatrix, skeletalPath);
1701         } else {
1702             if (!matrix.preConcat(*prePathMatrix)) {
1703                 return;
1704             }
1705         }
1706     }
1707
1708     //Apply path effect [Skeletal-path -> Fillable-path].
1709     SkPath* fillablePath = skeletalPath;
1710     if (paintHasPathEffect) {
1711         if (!pathIsMutable) {
1712             fillablePath = &modifiedPath;
1713             pathIsMutable = true;
1714         }
1715         bool fill = paint->getFillPath(*skeletalPath, fillablePath);
1716
1717         SkPaint* writablePaint = paint.writable();
1718         writablePaint->setPathEffect(NULL);
1719         if (fill) {
1720             writablePaint->setStyle(SkPaint::kFill_Style);
1721         } else {
1722             writablePaint->setStyle(SkPaint::kStroke_Style);
1723             writablePaint->setStrokeWidth(0);
1724         }
1725     }
1726
1727     //Create the shaded path. This will be the path which is painted.
1728     SkTScopedComPtr<IXpsOMPath> shadedPath;
1729     HRVM(this->fXpsFactory->CreatePath(&shadedPath),
1730          "Could not create shaded path for path.");
1731
1732     //Create the geometry for the shaded path.
1733     SkTScopedComPtr<IXpsOMGeometry> shadedGeometry;
1734     HRVM(this->fXpsFactory->CreateGeometry(&shadedGeometry),
1735          "Could not create shaded geometry for path.");
1736
1737     //Add the geometry to the shaded path.
1738     HRVM(shadedPath->SetGeometryLocal(shadedGeometry.get()),
1739          "Could not add the shaded geometry to shaded path.");
1740
1741     SkRasterizer* rasterizer = paint->getRasterizer();
1742     SkMaskFilter* filter = paint->getMaskFilter();
1743
1744     //Determine if we will draw or shade and mask.
1745     if (rasterizer || filter) {
1746         if (paint->getStyle() != SkPaint::kFill_Style) {
1747             paint.writable()->setStyle(SkPaint::kFill_Style);
1748         }
1749     }
1750
1751     //Set the brushes.
1752     BOOL fill;
1753     BOOL stroke;
1754     HRV(this->shadePath(shadedPath.get(),
1755                         *paint,
1756                         *d.fMatrix,
1757                         &fill,
1758                         &stroke));
1759
1760     //Rasterizer
1761     if (rasterizer) {
1762         SkIRect clipIRect;
1763         SkVector ppuScale;
1764         this->convertToPpm(filter,
1765                            &matrix,
1766                            &ppuScale,
1767                            d.fClip->getBounds(),
1768                            &clipIRect);
1769
1770         SkMask* mask = NULL;
1771
1772         //[Fillable-path -> Mask]
1773         SkMask rasteredMask;
1774         if (rasterizer->rasterize(
1775                 *fillablePath,
1776                 matrix,
1777                 &clipIRect,
1778                 filter,  //just to compute how much to draw.
1779                 &rasteredMask,
1780                 SkMask::kComputeBoundsAndRenderImage_CreateMode)) {
1781
1782             SkAutoMaskFreeImage rasteredAmi(rasteredMask.fImage);
1783             mask = &rasteredMask;
1784
1785             //[Mask -> Mask]
1786             SkMask filteredMask;
1787             if (filter &&
1788                 filter->filterMask(&filteredMask, *mask, *d.fMatrix, NULL)) {
1789
1790                 mask = &filteredMask;
1791             } else {
1792                 filteredMask.fImage = NULL;
1793             }
1794             SkAutoMaskFreeImage filteredAmi(filteredMask.fImage);
1795
1796             //Draw mask.
1797             HRV(this->applyMask(d, *mask, ppuScale, shadedPath.get()));
1798         }
1799         return;
1800     }
1801
1802     //Mask filter
1803     if (filter) {
1804         SkIRect clipIRect;
1805         SkVector ppuScale;
1806         this->convertToPpm(filter,
1807                            &matrix,
1808                            &ppuScale,
1809                            d.fClip->getBounds(),
1810                            &clipIRect);
1811
1812         //[Fillable-path -> Pixel-path]
1813         SkPath* pixelPath = pathIsMutable ? fillablePath : &modifiedPath;
1814         fillablePath->transform(matrix, pixelPath);
1815
1816         SkMask* mask = NULL;
1817
1818         //[Pixel-path -> Mask]
1819         SkMask rasteredMask;
1820         if (SkDraw::DrawToMask(
1821                         *pixelPath,
1822                         &clipIRect,
1823                         filter,  //just to compute how much to draw.
1824                         &matrix,
1825                         &rasteredMask,
1826                         SkMask::kComputeBoundsAndRenderImage_CreateMode,
1827                         paint->getStyle())) {
1828
1829             SkAutoMaskFreeImage rasteredAmi(rasteredMask.fImage);
1830             mask = &rasteredMask;
1831
1832             //[Mask -> Mask]
1833             SkMask filteredMask;
1834             if (filter->filterMask(&filteredMask,
1835                                    rasteredMask,
1836                                    matrix,
1837                                    NULL)) {
1838                 mask = &filteredMask;
1839             } else {
1840                 filteredMask.fImage = NULL;
1841             }
1842             SkAutoMaskFreeImage filteredAmi(filteredMask.fImage);
1843
1844             //Draw mask.
1845             HRV(this->applyMask(d, *mask, ppuScale, shadedPath.get()));
1846         }
1847         return;
1848     }
1849
1850     //Get the figures from the shaded geometry.
1851     SkTScopedComPtr<IXpsOMGeometryFigureCollection> shadedFigures;
1852     HRVM(shadedGeometry->GetFigures(&shadedFigures),
1853          "Could not get shaded figures for shaded path.");
1854
1855     bool xpsTransformsPath = true;
1856
1857     //Set the fill rule.
1858     XPS_FILL_RULE xpsFillRule;
1859     switch (platonicPath.getFillType()) {
1860         case SkPath::kWinding_FillType:
1861             xpsFillRule = XPS_FILL_RULE_NONZERO;
1862             break;
1863         case SkPath::kEvenOdd_FillType:
1864             xpsFillRule = XPS_FILL_RULE_EVENODD;
1865             break;
1866         case SkPath::kInverseWinding_FillType: {
1867             //[Fillable-path -> Device-path]
1868             SkPath* devicePath = pathIsMutable ? fillablePath : &modifiedPath;
1869             fillablePath->transform(matrix, devicePath);
1870
1871             HRV(this->drawInverseWindingPath(d,
1872                                              *devicePath,
1873                                              shadedPath.get()));
1874             return;
1875         }
1876         case SkPath::kInverseEvenOdd_FillType: {
1877             const SkRect universe = SkRect::MakeLTRB(
1878                 0, 0,
1879                 this->fCurrentCanvasSize.fWidth,
1880                 this->fCurrentCanvasSize.fHeight);
1881             SkTScopedComPtr<IXpsOMGeometryFigure> addOneFigure;
1882             HRV(this->createXpsRect(universe, FALSE, TRUE, &addOneFigure));
1883             HRVM(shadedFigures->Append(addOneFigure.get()),
1884                  "Could not add even-odd flip figure to shaded path.");
1885             xpsTransformsPath = false;
1886             xpsFillRule = XPS_FILL_RULE_EVENODD;
1887             break;
1888         }
1889         default:
1890             SkDEBUGFAIL("Unknown SkPath::FillType.");
1891     }
1892     HRVM(shadedGeometry->SetFillRule(xpsFillRule),
1893          "Could not set fill rule for shaded path.");
1894
1895     //Create the XPS transform, if possible.
1896     if (xpsTransformsPath) {
1897         SkTScopedComPtr<IXpsOMMatrixTransform> xpsTransform;
1898         HRV(this->createXpsTransform(matrix, &xpsTransform));
1899
1900         if (xpsTransform.get()) {
1901             HRVM(shadedGeometry->SetTransformLocal(xpsTransform.get()),
1902                  "Could not set transform on shaded path.");
1903         } else {
1904             xpsTransformsPath = false;
1905         }
1906     }
1907
1908     SkPath* devicePath = fillablePath;
1909     if (!xpsTransformsPath) {
1910         //[Fillable-path -> Device-path]
1911         devicePath = pathIsMutable ? fillablePath : &modifiedPath;
1912         fillablePath->transform(matrix, devicePath);
1913     }
1914     HRV(this->addXpsPathGeometry(shadedFigures.get(),
1915                                  stroke, fill, *devicePath));
1916
1917     HRV(this->clip(shadedPath.get(), d));
1918
1919     //Add the path to the active visual collection.
1920     SkTScopedComPtr<IXpsOMVisualCollection> currentVisuals;
1921     HRVM(this->fCurrentXpsCanvas->GetVisuals(&currentVisuals),
1922          "Could not get current visuals for shaded path.");
1923     HRVM(currentVisuals->Append(shadedPath.get()),
1924          "Could not add shaded path to current visuals.");
1925 }
1926
1927 HRESULT SkXPSDevice::clip(IXpsOMVisual* xpsVisual, const SkDraw& d) {
1928     SkPath clipPath;
1929     SkAssertResult(d.fClip->getBoundaryPath(&clipPath));
1930
1931     return this->clipToPath(xpsVisual, clipPath, XPS_FILL_RULE_EVENODD);
1932 }
1933 HRESULT SkXPSDevice::clipToPath(IXpsOMVisual* xpsVisual,
1934                                 const SkPath& clipPath,
1935                                 XPS_FILL_RULE fillRule) {
1936     //Create the geometry.
1937     SkTScopedComPtr<IXpsOMGeometry> clipGeometry;
1938     HRM(this->fXpsFactory->CreateGeometry(&clipGeometry),
1939         "Could not create clip geometry.");
1940
1941     //Get the figure collection of the geometry.
1942     SkTScopedComPtr<IXpsOMGeometryFigureCollection> clipFigures;
1943     HRM(clipGeometry->GetFigures(&clipFigures),
1944         "Could not get the clip figures.");
1945
1946     //Create the figures into the geometry.
1947     HR(this->addXpsPathGeometry(
1948         clipFigures.get(),
1949         FALSE, TRUE, clipPath));
1950
1951     HRM(clipGeometry->SetFillRule(fillRule),
1952         "Could not set fill rule.");
1953     HRM(xpsVisual->SetClipGeometryLocal(clipGeometry.get()),
1954         "Could not set clip geometry.");
1955
1956     return S_OK;
1957 }
1958
1959 void SkXPSDevice::drawBitmap(const SkDraw& d, const SkBitmap& bitmap,
1960                              const SkMatrix& matrix, const SkPaint& paint) {
1961     if (d.fClip->isEmpty()) {
1962         return;
1963     }
1964
1965     SkIRect srcRect;
1966     srcRect.set(0, 0, bitmap.width(), bitmap.height());
1967
1968     //Create the new shaded path.
1969     SkTScopedComPtr<IXpsOMPath> shadedPath;
1970     HRVM(this->fXpsFactory->CreatePath(&shadedPath),
1971          "Could not create path for bitmap.");
1972
1973     //Create the shaded geometry.
1974     SkTScopedComPtr<IXpsOMGeometry> shadedGeometry;
1975     HRVM(this->fXpsFactory->CreateGeometry(&shadedGeometry),
1976          "Could not create geometry for bitmap.");
1977
1978     //Add the shaded geometry to the shaded path.
1979     HRVM(shadedPath->SetGeometryLocal(shadedGeometry.get()),
1980          "Could not set the geometry for bitmap.");
1981
1982     //Get the shaded figures from the shaded geometry.
1983     SkTScopedComPtr<IXpsOMGeometryFigureCollection> shadedFigures;
1984     HRVM(shadedGeometry->GetFigures(&shadedFigures),
1985          "Could not get the figures for bitmap.");
1986
1987     SkMatrix transform = matrix;
1988     transform.postConcat(*d.fMatrix);
1989
1990     SkTScopedComPtr<IXpsOMMatrixTransform> xpsTransform;
1991     HRV(this->createXpsTransform(transform, &xpsTransform));
1992     if (xpsTransform.get()) {
1993         HRVM(shadedGeometry->SetTransformLocal(xpsTransform.get()),
1994              "Could not set transform for bitmap.");
1995     } else {
1996         //TODO: perspective that bitmap!
1997     }
1998
1999     SkTScopedComPtr<IXpsOMGeometryFigure> rectFigure;
2000     if (NULL != xpsTransform.get()) {
2001         const SkShader::TileMode xy[2] = {
2002             SkShader::kClamp_TileMode,
2003             SkShader::kClamp_TileMode,
2004         };
2005         SkTScopedComPtr<IXpsOMTileBrush> xpsImageBrush;
2006         HRV(this->createXpsImageBrush(bitmap,
2007                                       transform,
2008                                       xy,
2009                                       paint.getAlpha(),
2010                                       &xpsImageBrush));
2011         HRVM(shadedPath->SetFillBrushLocal(xpsImageBrush.get()),
2012              "Could not set bitmap brush.");
2013
2014         const SkRect bitmapRect = SkRect::MakeLTRB(0, 0,
2015             SkIntToScalar(srcRect.width()), SkIntToScalar(srcRect.height()));
2016         HRV(this->createXpsRect(bitmapRect, FALSE, TRUE, &rectFigure));
2017     }
2018     HRVM(shadedFigures->Append(rectFigure.get()),
2019          "Could not add bitmap figure.");
2020
2021     //Get the current visual collection and add the shaded path to it.
2022     SkTScopedComPtr<IXpsOMVisualCollection> currentVisuals;
2023     HRVM(this->fCurrentXpsCanvas->GetVisuals(&currentVisuals),
2024          "Could not get current visuals for bitmap");
2025     HRVM(currentVisuals->Append(shadedPath.get()),
2026          "Could not add bitmap to current visuals.");
2027
2028     HRV(this->clip(shadedPath.get(), d));
2029 }
2030
2031 void SkXPSDevice::drawSprite(const SkDraw&, const SkBitmap& bitmap,
2032                              int x, int y,
2033                              const SkPaint& paint) {
2034     //TODO: override this for XPS
2035     SkDEBUGF(("XPS drawSprite not yet implemented."));
2036 }
2037
2038 HRESULT SkXPSDevice::CreateTypefaceUse(const SkPaint& paint,
2039                                        TypefaceUse** typefaceUse) {
2040     SkAutoResolveDefaultTypeface typeface(paint.getTypeface());
2041
2042     //Check cache.
2043     const SkFontID typefaceID = typeface->uniqueID();
2044     if (!this->fTypefaces.empty()) {
2045         TypefaceUse* current = &this->fTypefaces.front();
2046         const TypefaceUse* last = &this->fTypefaces.back();
2047         for (; current <= last; ++current) {
2048             if (current->typefaceId == typefaceID) {
2049                 *typefaceUse = current;
2050                 return S_OK;
2051             }
2052         }
2053     }
2054
2055     //TODO: create glyph only fonts
2056     //and let the host deal with what kind of font we're looking at.
2057     XPS_FONT_EMBEDDING embedding = XPS_FONT_EMBEDDING_RESTRICTED;
2058
2059     SkTScopedComPtr<IStream> fontStream;
2060     int ttcIndex;
2061     SkStream* fontData = typeface->openStream(&ttcIndex);
2062     //TODO: cannot handle FON fonts.
2063     HRM(SkIStream::CreateFromSkStream(fontData, true, &fontStream),
2064         "Could not create font stream.");
2065
2066     const size_t size =
2067         SK_ARRAY_COUNT(L"/Resources/Fonts/" L_GUID_ID L".odttf");
2068     wchar_t buffer[size];
2069     wchar_t id[GUID_ID_LEN];
2070     HR(create_id(id, GUID_ID_LEN));
2071     swprintf_s(buffer, size, L"/Resources/Fonts/%s.odttf", id);
2072
2073     SkTScopedComPtr<IOpcPartUri> partUri;
2074     HRM(this->fXpsFactory->CreatePartUri(buffer, &partUri),
2075         "Could not create font resource part uri.");
2076
2077     SkTScopedComPtr<IXpsOMFontResource> xpsFontResource;
2078     HRM(this->fXpsFactory->CreateFontResource(fontStream.get(),
2079                                               embedding,
2080                                               partUri.get(),
2081                                               FALSE,
2082                                               &xpsFontResource),
2083         "Could not create font resource.");
2084
2085     //TODO: change openStream to return -1 for non-ttc, get rid of this.
2086     uint8_t* data = (uint8_t*)fontData->getMemoryBase();
2087     bool isTTC = (data &&
2088                   fontData->getLength() >= sizeof(SkTTCFHeader) &&
2089                   ((SkTTCFHeader*)data)->ttcTag == SkTTCFHeader::TAG);
2090
2091     TypefaceUse& newTypefaceUse = this->fTypefaces.push_back();
2092     newTypefaceUse.typefaceId = typefaceID;
2093     newTypefaceUse.ttcIndex = isTTC ? ttcIndex : -1;
2094     newTypefaceUse.fontData = fontData;
2095     newTypefaceUse.xpsFont = xpsFontResource.release();
2096
2097     SkAutoGlyphCache agc(paint, NULL, &SkMatrix::I());
2098     SkGlyphCache* glyphCache = agc.getCache();
2099     unsigned int glyphCount = glyphCache->getGlyphCount();
2100     newTypefaceUse.glyphsUsed = new SkBitSet(glyphCount);
2101
2102     *typefaceUse = &newTypefaceUse;
2103     return S_OK;
2104 }
2105
2106 HRESULT SkXPSDevice::AddGlyphs(const SkDraw& d,
2107                                IXpsOMObjectFactory* xpsFactory,
2108                                IXpsOMCanvas* canvas,
2109                                TypefaceUse* font,
2110                                LPCWSTR text,
2111                                XPS_GLYPH_INDEX* xpsGlyphs,
2112                                UINT32 xpsGlyphsLen,
2113                                XPS_POINT *origin,
2114                                FLOAT fontSize,
2115                                XPS_STYLE_SIMULATION sims,
2116                                const SkMatrix& transform,
2117                                const SkPaint& paint) {
2118     SkTScopedComPtr<IXpsOMGlyphs> glyphs;
2119     HRM(xpsFactory->CreateGlyphs(font->xpsFont, &glyphs), "Could not create glyphs.");
2120     HRM(glyphs->SetFontFaceIndex(font->ttcIndex), "Could not set glyph font face index.");
2121
2122     //XPS uses affine transformations for everything...
2123     //...except positioning text.
2124     bool useCanvasForClip;
2125     if ((transform.getType() & ~SkMatrix::kTranslate_Mask) == 0) {
2126         origin->x += SkScalarToFLOAT(transform.getTranslateX());
2127         origin->y += SkScalarToFLOAT(transform.getTranslateY());
2128         useCanvasForClip = false;
2129     } else {
2130         SkTScopedComPtr<IXpsOMMatrixTransform> xpsMatrixToUse;
2131         HR(this->createXpsTransform(transform, &xpsMatrixToUse));
2132         if (xpsMatrixToUse.get()) {
2133             HRM(glyphs->SetTransformLocal(xpsMatrixToUse.get()),
2134                 "Could not set transform matrix.");
2135             useCanvasForClip = true;
2136         } else {
2137             SkDEBUGFAIL("Attempt to add glyphs in perspective.");
2138             useCanvasForClip = false;
2139         }
2140     }
2141
2142     SkTScopedComPtr<IXpsOMGlyphsEditor> glyphsEditor;
2143     HRM(glyphs->GetGlyphsEditor(&glyphsEditor), "Could not get glyph editor.");
2144
2145     if (NULL != text) {
2146         HRM(glyphsEditor->SetUnicodeString(text),
2147             "Could not set unicode string.");
2148     }
2149
2150     if (NULL != xpsGlyphs) {
2151         HRM(glyphsEditor->SetGlyphIndices(xpsGlyphsLen, xpsGlyphs),
2152             "Could not set glyphs.");
2153     }
2154
2155     HRM(glyphsEditor->ApplyEdits(), "Could not apply glyph edits.");
2156
2157     SkTScopedComPtr<IXpsOMBrush> xpsFillBrush;
2158     HR(this->createXpsBrush(
2159             paint,
2160             &xpsFillBrush,
2161             useCanvasForClip ? NULL : &transform));
2162
2163     HRM(glyphs->SetFillBrushLocal(xpsFillBrush.get()),
2164         "Could not set fill brush.");
2165
2166     HRM(glyphs->SetOrigin(origin), "Could not set glyph origin.");
2167
2168     HRM(glyphs->SetFontRenderingEmSize(fontSize),
2169         "Could not set font size.");
2170
2171     HRM(glyphs->SetStyleSimulations(sims),
2172         "Could not set style simulations.");
2173
2174     SkTScopedComPtr<IXpsOMVisualCollection> visuals;
2175     HRM(canvas->GetVisuals(&visuals), "Could not get glyph canvas visuals.");
2176
2177     if (!useCanvasForClip) {
2178         HR(this->clip(glyphs.get(), d));
2179         HRM(visuals->Append(glyphs.get()), "Could not add glyphs to canvas.");
2180     } else {
2181         SkTScopedComPtr<IXpsOMCanvas> glyphCanvas;
2182         HRM(this->fXpsFactory->CreateCanvas(&glyphCanvas),
2183             "Could not create glyph canvas.");
2184
2185         SkTScopedComPtr<IXpsOMVisualCollection> glyphCanvasVisuals;
2186         HRM(glyphCanvas->GetVisuals(&glyphCanvasVisuals),
2187             "Could not get glyph visuals collection.");
2188
2189         HRM(glyphCanvasVisuals->Append(glyphs.get()),
2190             "Could not add glyphs to page.");
2191         HR(this->clip(glyphCanvas.get(), d));
2192
2193         HRM(visuals->Append(glyphCanvas.get()),
2194             "Could not add glyph canvas to page.");
2195     }
2196
2197     return S_OK;
2198 }
2199
2200 struct SkXPSDrawProcs : public SkDrawProcs {
2201 public:
2202     /** [in] Advance width and offsets for glyphs measured in
2203     hundredths of the font em size (XPS Spec 5.1.3). */
2204     FLOAT centemPerUnit;
2205     /** [in,out] The accumulated glyphs used in the current typeface. */
2206     SkBitSet* glyphUse;
2207     /** [out] The glyphs to draw. */
2208     SkTDArray<XPS_GLYPH_INDEX> xpsGlyphs;
2209 };
2210
2211 static void xps_draw_1_glyph(const SkDraw1Glyph& state,
2212                              SkFixed x, SkFixed y,
2213                              const SkGlyph& skGlyph) {
2214     SkASSERT(skGlyph.fWidth > 0 && skGlyph.fHeight > 0);
2215
2216     SkXPSDrawProcs* procs = static_cast<SkXPSDrawProcs*>(state.fDraw->fProcs);
2217
2218     //Draw pre-adds half the sampling frequency for floor rounding.
2219     x -= state.fHalfSampleX;
2220     y -= state.fHalfSampleY;
2221
2222     XPS_GLYPH_INDEX* xpsGlyph = procs->xpsGlyphs.append();
2223     uint16_t glyphID = skGlyph.getGlyphID();
2224     procs->glyphUse->setBit(glyphID, true);
2225     xpsGlyph->index = glyphID;
2226     if (1 == procs->xpsGlyphs.count()) {
2227         xpsGlyph->advanceWidth = 0.0f;
2228         xpsGlyph->horizontalOffset = SkFixedToFloat(x) * procs->centemPerUnit;
2229         xpsGlyph->verticalOffset = SkFixedToFloat(y) * -procs->centemPerUnit;
2230     } else {
2231         const XPS_GLYPH_INDEX& first = procs->xpsGlyphs[0];
2232         xpsGlyph->advanceWidth = 0.0f;
2233         xpsGlyph->horizontalOffset = (SkFixedToFloat(x) * procs->centemPerUnit)
2234                                      - first.horizontalOffset;
2235         xpsGlyph->verticalOffset = (SkFixedToFloat(y) * -procs->centemPerUnit)
2236                                    - first.verticalOffset;
2237     }
2238 }
2239
2240 static void text_draw_init(const SkPaint& paint,
2241                            const void* text, size_t byteLength,
2242                            SkBitSet& glyphsUsed,
2243                            SkDraw& myDraw, SkXPSDrawProcs& procs) {
2244     procs.fD1GProc = xps_draw_1_glyph;
2245     size_t numGlyphGuess;
2246     switch (paint.getTextEncoding()) {
2247         case SkPaint::kUTF8_TextEncoding:
2248             numGlyphGuess = SkUTF8_CountUnichars(
2249                 static_cast<const char *>(text),
2250                 byteLength);
2251             break;
2252         case SkPaint::kUTF16_TextEncoding:
2253             numGlyphGuess = SkUTF16_CountUnichars(
2254                 static_cast<const uint16_t *>(text),
2255                 byteLength);
2256             break;
2257         case SkPaint::kGlyphID_TextEncoding:
2258             numGlyphGuess = byteLength / 2;
2259             break;
2260         default:
2261             SK_DEBUGBREAK(true);
2262     }
2263     procs.xpsGlyphs.setReserve(numGlyphGuess);
2264     procs.glyphUse = &glyphsUsed;
2265     procs.centemPerUnit = 100.0f / SkScalarToFLOAT(paint.getTextSize());
2266
2267     myDraw.fProcs = &procs;
2268 }
2269
2270 static bool text_must_be_pathed(const SkPaint& paint, const SkMatrix& matrix) {
2271     const SkPaint::Style style = paint.getStyle();
2272     return matrix.hasPerspective()
2273         || SkPaint::kStroke_Style == style
2274         || SkPaint::kStrokeAndFill_Style == style
2275         || paint.getMaskFilter()
2276         || paint.getRasterizer()
2277     ;
2278 }
2279
2280 void SkXPSDevice::drawText(const SkDraw& d,
2281                            const void* text, size_t byteLen,
2282                            SkScalar x, SkScalar y,
2283                            const SkPaint& paint) {
2284     if (byteLen < 1) return;
2285
2286     if (text_must_be_pathed(paint, *d.fMatrix)) {
2287         SkPath path;
2288         paint.getTextPath(text, byteLen, x, y, &path);
2289         this->drawPath(d, path, paint, NULL, true);
2290         //TODO: add automation "text"
2291         return;
2292     }
2293
2294     TypefaceUse* typeface;
2295     HRV(CreateTypefaceUse(paint, &typeface));
2296
2297     SkDraw myDraw(d);
2298     myDraw.fMatrix = &SkMatrix::I();
2299     SkXPSDrawProcs procs;
2300     text_draw_init(paint, text, byteLen, *typeface->glyphsUsed, myDraw, procs);
2301
2302     myDraw.drawText(static_cast<const char*>(text), byteLen, x, y, paint);
2303
2304     // SkDraw may have clipped out the glyphs, so we need to check
2305     if (procs.xpsGlyphs.count() == 0) {
2306         return;
2307     }
2308
2309     XPS_POINT origin = {
2310         procs.xpsGlyphs[0].horizontalOffset / procs.centemPerUnit,
2311         procs.xpsGlyphs[0].verticalOffset / -procs.centemPerUnit,
2312     };
2313     procs.xpsGlyphs[0].horizontalOffset = 0.0f;
2314     procs.xpsGlyphs[0].verticalOffset = 0.0f;
2315
2316     HRV(AddGlyphs(d,
2317                   this->fXpsFactory.get(),
2318                   this->fCurrentXpsCanvas.get(),
2319                   typeface,
2320                   NULL,
2321                   procs.xpsGlyphs.begin(), procs.xpsGlyphs.count(),
2322                   &origin,
2323                   SkScalarToFLOAT(paint.getTextSize()),
2324                   XPS_STYLE_SIMULATION_NONE,
2325                   *d.fMatrix,
2326                   paint));
2327 }
2328
2329 void SkXPSDevice::drawPosText(const SkDraw& d,
2330                               const void* text, size_t byteLen,
2331                               const SkScalar pos[],
2332                               SkScalar constY, int scalarsPerPos,
2333                               const SkPaint& paint) {
2334     if (byteLen < 1) return;
2335
2336     if (text_must_be_pathed(paint, *d.fMatrix)) {
2337         SkPath path;
2338         //TODO: make this work, Draw currently does not handle as well.
2339         //paint.getTextPath(text, byteLength, x, y, &path);
2340         //this->drawPath(d, path, paint, NULL, true);
2341         //TODO: add automation "text"
2342         return;
2343     }
2344
2345     TypefaceUse* typeface;
2346     HRV(CreateTypefaceUse(paint, &typeface));
2347
2348     SkDraw myDraw(d);
2349     myDraw.fMatrix = &SkMatrix::I();
2350     SkXPSDrawProcs procs;
2351     text_draw_init(paint, text, byteLen, *typeface->glyphsUsed, myDraw, procs);
2352
2353     myDraw.drawPosText(static_cast<const char*>(text), byteLen,
2354                        pos, constY, scalarsPerPos,
2355                        paint);
2356
2357     // SkDraw may have clipped out the glyphs, so we need to check
2358     if (procs.xpsGlyphs.count() == 0) {
2359         return;
2360     }
2361
2362     XPS_POINT origin = {
2363         procs.xpsGlyphs[0].horizontalOffset / procs.centemPerUnit,
2364         procs.xpsGlyphs[0].verticalOffset / -procs.centemPerUnit,
2365     };
2366     procs.xpsGlyphs[0].horizontalOffset = 0.0f;
2367     procs.xpsGlyphs[0].verticalOffset = 0.0f;
2368
2369     HRV(AddGlyphs(d,
2370                   this->fXpsFactory.get(),
2371                   this->fCurrentXpsCanvas.get(),
2372                   typeface,
2373                   NULL,
2374                   procs.xpsGlyphs.begin(), procs.xpsGlyphs.count(),
2375                   &origin,
2376                   SkScalarToFLOAT(paint.getTextSize()),
2377                   XPS_STYLE_SIMULATION_NONE,
2378                   *d.fMatrix,
2379                   paint));
2380 }
2381
2382 void SkXPSDevice::drawTextOnPath(const SkDraw& d, const void* text, size_t len,
2383                                  const SkPath& path, const SkMatrix* matrix,
2384                                  const SkPaint& paint) {
2385     //This will call back into the device to do the drawing.
2386      d.drawTextOnPath((const char*)text, len, path, matrix, paint);
2387 }
2388
2389 void SkXPSDevice::drawDevice(const SkDraw& d, SkBaseDevice* dev,
2390                              int x, int y,
2391                              const SkPaint&) {
2392     SkXPSDevice* that = static_cast<SkXPSDevice*>(dev);
2393
2394     SkTScopedComPtr<IXpsOMMatrixTransform> xpsTransform;
2395     XPS_MATRIX rawTransform = {
2396         1.0f,
2397         0.0f,
2398         0.0f,
2399         1.0f,
2400         static_cast<FLOAT>(x),
2401         static_cast<FLOAT>(y),
2402     };
2403     HRVM(this->fXpsFactory->CreateMatrixTransform(&rawTransform, &xpsTransform),
2404          "Could not create layer transform.");
2405     HRVM(that->fCurrentXpsCanvas->SetTransformLocal(xpsTransform.get()),
2406          "Could not set layer transform.");
2407
2408     //Get the current visual collection and add the layer to it.
2409     SkTScopedComPtr<IXpsOMVisualCollection> currentVisuals;
2410     HRVM(this->fCurrentXpsCanvas->GetVisuals(&currentVisuals),
2411          "Could not get current visuals for layer.");
2412     HRVM(currentVisuals->Append(that->fCurrentXpsCanvas.get()),
2413          "Could not add layer to current visuals.");
2414 }
2415
2416 bool SkXPSDevice::onReadPixels(const SkBitmap& bitmap, int x, int y,
2417                                SkCanvas::Config8888) {
2418     return false;
2419 }
2420
2421 SkBaseDevice* SkXPSDevice::onCreateCompatibleDevice(SkBitmap::Config config,
2422                                                     int width, int height,
2423                                                     bool isOpaque,
2424                                                     Usage usage) {
2425
2426 //Conditional for bug compatibility with PDF device.
2427 #if 0
2428     if (SkBaseDevice::kGeneral_Usage == usage) {
2429         return NULL;
2430         SK_CRASH();
2431         //To what stream do we write?
2432         //SkXPSDevice* dev = new SkXPSDevice(this);
2433         //SkSize s = SkSize::Make(width, height);
2434         //dev->BeginCanvas(s, s, SkMatrix::I());
2435         //return dev;
2436     }
2437 #endif
2438     return new SkXPSDevice(this->fXpsFactory.get());
2439 }
2440
2441 SkXPSDevice::SkXPSDevice(IXpsOMObjectFactory* xpsFactory)
2442     : SkBitmapDevice(make_fake_bitmap(10000, 10000))
2443     , fCurrentPage(0) {
2444
2445     HRVM(CoCreateInstance(
2446              CLSID_XpsOMObjectFactory,
2447              NULL,
2448              CLSCTX_INPROC_SERVER,
2449              IID_PPV_ARGS(&this->fXpsFactory)),
2450          "Could not create factory for layer.");
2451
2452     HRVM(this->fXpsFactory->CreateCanvas(&this->fCurrentXpsCanvas),
2453          "Could not create canvas for layer.");
2454 }
2455
2456 bool SkXPSDevice::allowImageFilter(const SkImageFilter*) {
2457     return false;
2458 }