XPS, DM: add SkDocument::CreateXPS

src/device/xps/SkXPSDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
+#include "SkTypes.h"
+
+#ifdef SK_SUPPORT_XPS
+
 #ifndef UNICODE
 #define UNICODE
 #endif
 #ifndef _UNICODE
 #define _UNICODE
 #endif
-#include "SkTypes.h"
 #include <ObjBase.h>
 #include <XpsObjectModel.h>
 #include <T2EmbApi.h>
 #include <FontSub.h>
 
 #include "SkColor.h"
 #include "SkConstexprMath.h"
 #include "SkData.h"
 #include "SkDraw.h"
 #include "SkDrawProcs.h"
 #include "SkEndian.h"
+#include "SkGeometry.h"
 #include "SkGlyphCache.h"
 #include "SkHRESULT.h"
 #include "SkImageEncoder.h"
 #include "SkIStream.h"
 #include "SkMaskFilter.h"
 #include "SkPaint.h"
 #include "SkPathOps.h"
 #include "SkPoint.h"
 #include "SkRasterizer.h"
 #include "SkSFNTHeader.h"
@@ skipping 1320 matching lines @@
             case SkPath::kCubic_Verb:
                 segmentTypes.push(XPS_SEGMENT_TYPE_BEZIER);
                 segmentStrokes.push(stroke);
                 segmentData.push(SkScalarToFLOAT(points[1].fX));
                 segmentData.push(SkScalarToFLOAT(points[1].fY));
                 segmentData.push(SkScalarToFLOAT(points[2].fX));
                 segmentData.push(SkScalarToFLOAT(points[2].fY));
                 segmentData.push(SkScalarToFLOAT(points[3].fX));
                 segmentData.push(SkScalarToFLOAT(points[3].fY));
                 break;
+            case SkPath::kConic_Verb: {
+                const SkScalar tol = SK_Scalar1 / 4;
+                SkAutoConicToQuads converter;
+                const SkPoint* quads = converter.computeQuads(points, iter.conicWeight(), tol);
+                for (int i = 0; i < converter.countQuads(); ++i) {
+                    segmentTypes.push(XPS_SEGMENT_TYPE_QUADRATIC_BEZIER);
+                    segmentStrokes.push(stroke);
+                    segmentData.push(SkScalarToFLOAT(quads[2 * i + 1].fX));
+                    segmentData.push(SkScalarToFLOAT(quads[2 * i + 1].fY));
+                    segmentData.push(SkScalarToFLOAT(quads[2 * i + 2].fX));
+                    segmentData.push(SkScalarToFLOAT(quads[2 * i + 2].fY));
+                }
+                break;
+            }
             case SkPath::kClose_Verb:
                 // we ignore these, and just get the whole segment from
                 // the corresponding line/quad/cubic verbs
                 break;
             default:
                 SkDEBUGFAIL("unexpected verb");
                 break;
         }
     }
     if (xpsFigure.get()) {
@@ skipping 824 matching lines @@
                   typeface,
                   NULL,
                   procs.xpsGlyphs.begin(), procs.xpsGlyphs.count(),
                   &origin,
                   SkScalarToFLOAT(paint.getTextSize()),
                   XPS_STYLE_SIMULATION_NONE,
                   *d.fMatrix,
                   paint));
 }
 
-void SkXPSDevice::drawTextOnPath(const SkDraw& d, const void* text, size_t len,
-                                 const SkPath& path, const SkMatrix* matrix,
-                                 const SkPaint& paint) {
-    //This will call back into the device to do the drawing.
-     d.drawTextOnPath((const char*)text, len, path, matrix, paint);
-}
-
 void SkXPSDevice::drawDevice(const SkDraw& d, SkBaseDevice* dev,
                              int x, int y,
                              const SkPaint&) {
     SkXPSDevice* that = static_cast<SkXPSDevice*>(dev);
 
     SkTScopedComPtr<IXpsOMMatrixTransform> xpsTransform;
     XPS_MATRIX rawTransform = {
         1.0f,
         0.0f,
         0.0f,
@@ skipping 41 matching lines @@
              IID_PPV_ARGS(&this->fXpsFactory)),
          "Could not create factory for layer.");
 
     HRVM(this->fXpsFactory->CreateCanvas(&this->fCurrentXpsCanvas),
          "Could not create canvas for layer.");
 }
 
 bool SkXPSDevice::allowImageFilter(const SkImageFilter*) {
     return false;
 }
+
+#endif  // SK_SUPPORT_XPS